{-# LANGUAGE DataKinds                  #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE Strict                     #-}
module Graphics.Vulkan.Types.Bitmasks
       (VkAndroidSurfaceCreateFlagsKHR(..), VkBufferViewCreateFlags(..),
        VkBuildAccelerationStructureFlagsNV(..),
        VkCommandPoolTrimFlags(..), VkCommandPoolTrimFlagsKHR(..),
        VkDebugUtilsMessengerCallbackDataFlagsEXT(..),
        VkDebugUtilsMessengerCreateFlagsEXT(..),
        VkDescriptorBindingFlagsEXT(..), VkDescriptorPoolResetFlags(..),
        VkDescriptorUpdateTemplateCreateFlags(..),
        VkDescriptorUpdateTemplateCreateFlagsKHR(..),
        VkDeviceCreateFlags(..), VkDirectFBSurfaceCreateFlagsEXT(..),
        VkDisplayModeCreateFlagsKHR(..),
        VkDisplaySurfaceCreateFlagsKHR(..), VkEventCreateFlags(..),
        VkExternalFenceFeatureFlagsKHR(..),
        VkExternalFenceHandleTypeFlagsKHR(..),
        VkExternalMemoryFeatureFlagsKHR(..),
        VkExternalMemoryHandleTypeFlagsKHR(..),
        VkExternalSemaphoreFeatureFlagsKHR(..),
        VkExternalSemaphoreHandleTypeFlagsKHR(..),
        VkFenceImportFlagsKHR(..), VkGeometryFlagsNV(..),
        VkGeometryInstanceFlagsNV(..), VkHeadlessSurfaceCreateFlagsEXT(..),
        VkIOSSurfaceCreateFlagsMVK(..),
        VkImagePipeSurfaceCreateFlagsFUCHSIA(..),
        VkInstanceCreateFlags(..), VkMacOSSurfaceCreateFlagsMVK(..),
        VkMemoryAllocateFlagsKHR(..), VkMemoryMapFlags(..),
        VkMetalSurfaceCreateFlagsEXT(..), VkPeerMemoryFeatureFlagsKHR(..),
        VkPipelineColorBlendStateCreateFlags(..),
        VkPipelineCoverageModulationStateCreateFlagsNV(..),
        VkPipelineCoverageReductionStateCreateFlagsNV(..),
        VkPipelineCoverageToColorStateCreateFlagsNV(..),
        VkPipelineDepthStencilStateCreateFlags(..),
        VkPipelineDiscardRectangleStateCreateFlagsEXT(..),
        VkPipelineDynamicStateCreateFlags(..),
        VkPipelineInputAssemblyStateCreateFlags(..),
        VkPipelineLayoutCreateFlags(..),
        VkPipelineMultisampleStateCreateFlags(..),
        VkPipelineRasterizationConservativeStateCreateFlagsEXT(..),
        VkPipelineRasterizationDepthClipStateCreateFlagsEXT(..),
        VkPipelineRasterizationStateCreateFlags(..),
        VkPipelineRasterizationStateStreamCreateFlagsEXT(..),
        VkPipelineTessellationStateCreateFlags(..),
        VkPipelineVertexInputStateCreateFlags(..),
        VkPipelineViewportStateCreateFlags(..),
        VkPipelineViewportSwizzleStateCreateFlagsNV(..),
        VkQueryPoolCreateFlags(..), VkResolveModeFlagsKHR(..),
        VkSemaphoreCreateFlags(..), VkSemaphoreImportFlagsKHR(..),
        VkSemaphoreWaitFlagsKHR(..),
        VkStreamDescriptorSurfaceCreateFlagsGGP(..),
        VkValidationCacheCreateFlagsEXT(..), VkViSurfaceCreateFlagsNN(..),
        VkWaylandSurfaceCreateFlagsKHR(..),
        VkWin32SurfaceCreateFlagsKHR(..), VkXcbSurfaceCreateFlagsKHR(..),
        VkXlibSurfaceCreateFlagsKHR(..))
       where
import Data.Bits                       (Bits, FiniteBits)
import Data.Coerce                     (coerce)
import Foreign.Storable                (Storable)
import Graphics.Vulkan.Types.BaseTypes (VkFlags)

newtype VkAndroidSurfaceCreateFlagsKHR = VkAndroidSurfaceCreateFlagsKHR VkFlags
                                         deriving (VkAndroidSurfaceCreateFlagsKHR
-> VkAndroidSurfaceCreateFlagsKHR -> Bool
(VkAndroidSurfaceCreateFlagsKHR
 -> VkAndroidSurfaceCreateFlagsKHR -> Bool)
-> (VkAndroidSurfaceCreateFlagsKHR
    -> VkAndroidSurfaceCreateFlagsKHR -> Bool)
-> Eq VkAndroidSurfaceCreateFlagsKHR
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VkAndroidSurfaceCreateFlagsKHR
-> VkAndroidSurfaceCreateFlagsKHR -> Bool
$c/= :: VkAndroidSurfaceCreateFlagsKHR
-> VkAndroidSurfaceCreateFlagsKHR -> Bool
== :: VkAndroidSurfaceCreateFlagsKHR
-> VkAndroidSurfaceCreateFlagsKHR -> Bool
$c== :: VkAndroidSurfaceCreateFlagsKHR
-> VkAndroidSurfaceCreateFlagsKHR -> Bool
Eq, Eq VkAndroidSurfaceCreateFlagsKHR
Eq VkAndroidSurfaceCreateFlagsKHR
-> (VkAndroidSurfaceCreateFlagsKHR
    -> VkAndroidSurfaceCreateFlagsKHR -> Ordering)
-> (VkAndroidSurfaceCreateFlagsKHR
    -> VkAndroidSurfaceCreateFlagsKHR -> Bool)
-> (VkAndroidSurfaceCreateFlagsKHR
    -> VkAndroidSurfaceCreateFlagsKHR -> Bool)
-> (VkAndroidSurfaceCreateFlagsKHR
    -> VkAndroidSurfaceCreateFlagsKHR -> Bool)
-> (VkAndroidSurfaceCreateFlagsKHR
    -> VkAndroidSurfaceCreateFlagsKHR -> Bool)
-> (VkAndroidSurfaceCreateFlagsKHR
    -> VkAndroidSurfaceCreateFlagsKHR
    -> VkAndroidSurfaceCreateFlagsKHR)
-> (VkAndroidSurfaceCreateFlagsKHR
    -> VkAndroidSurfaceCreateFlagsKHR
    -> VkAndroidSurfaceCreateFlagsKHR)
-> Ord VkAndroidSurfaceCreateFlagsKHR
VkAndroidSurfaceCreateFlagsKHR
-> VkAndroidSurfaceCreateFlagsKHR -> Bool
VkAndroidSurfaceCreateFlagsKHR
-> VkAndroidSurfaceCreateFlagsKHR -> Ordering
VkAndroidSurfaceCreateFlagsKHR
-> VkAndroidSurfaceCreateFlagsKHR -> VkAndroidSurfaceCreateFlagsKHR
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: VkAndroidSurfaceCreateFlagsKHR
-> VkAndroidSurfaceCreateFlagsKHR -> VkAndroidSurfaceCreateFlagsKHR
$cmin :: VkAndroidSurfaceCreateFlagsKHR
-> VkAndroidSurfaceCreateFlagsKHR -> VkAndroidSurfaceCreateFlagsKHR
max :: VkAndroidSurfaceCreateFlagsKHR
-> VkAndroidSurfaceCreateFlagsKHR -> VkAndroidSurfaceCreateFlagsKHR
$cmax :: VkAndroidSurfaceCreateFlagsKHR
-> VkAndroidSurfaceCreateFlagsKHR -> VkAndroidSurfaceCreateFlagsKHR
>= :: VkAndroidSurfaceCreateFlagsKHR
-> VkAndroidSurfaceCreateFlagsKHR -> Bool
$c>= :: VkAndroidSurfaceCreateFlagsKHR
-> VkAndroidSurfaceCreateFlagsKHR -> Bool
> :: VkAndroidSurfaceCreateFlagsKHR
-> VkAndroidSurfaceCreateFlagsKHR -> Bool
$c> :: VkAndroidSurfaceCreateFlagsKHR
-> VkAndroidSurfaceCreateFlagsKHR -> Bool
<= :: VkAndroidSurfaceCreateFlagsKHR
-> VkAndroidSurfaceCreateFlagsKHR -> Bool
$c<= :: VkAndroidSurfaceCreateFlagsKHR
-> VkAndroidSurfaceCreateFlagsKHR -> Bool
< :: VkAndroidSurfaceCreateFlagsKHR
-> VkAndroidSurfaceCreateFlagsKHR -> Bool
$c< :: VkAndroidSurfaceCreateFlagsKHR
-> VkAndroidSurfaceCreateFlagsKHR -> Bool
compare :: VkAndroidSurfaceCreateFlagsKHR
-> VkAndroidSurfaceCreateFlagsKHR -> Ordering
$ccompare :: VkAndroidSurfaceCreateFlagsKHR
-> VkAndroidSurfaceCreateFlagsKHR -> Ordering
Ord, Int -> VkAndroidSurfaceCreateFlagsKHR
VkAndroidSurfaceCreateFlagsKHR -> Int
VkAndroidSurfaceCreateFlagsKHR -> [VkAndroidSurfaceCreateFlagsKHR]
VkAndroidSurfaceCreateFlagsKHR -> VkAndroidSurfaceCreateFlagsKHR
VkAndroidSurfaceCreateFlagsKHR
-> VkAndroidSurfaceCreateFlagsKHR
-> [VkAndroidSurfaceCreateFlagsKHR]
VkAndroidSurfaceCreateFlagsKHR
-> VkAndroidSurfaceCreateFlagsKHR
-> VkAndroidSurfaceCreateFlagsKHR
-> [VkAndroidSurfaceCreateFlagsKHR]
(VkAndroidSurfaceCreateFlagsKHR -> VkAndroidSurfaceCreateFlagsKHR)
-> (VkAndroidSurfaceCreateFlagsKHR
    -> VkAndroidSurfaceCreateFlagsKHR)
-> (Int -> VkAndroidSurfaceCreateFlagsKHR)
-> (VkAndroidSurfaceCreateFlagsKHR -> Int)
-> (VkAndroidSurfaceCreateFlagsKHR
    -> [VkAndroidSurfaceCreateFlagsKHR])
-> (VkAndroidSurfaceCreateFlagsKHR
    -> VkAndroidSurfaceCreateFlagsKHR
    -> [VkAndroidSurfaceCreateFlagsKHR])
-> (VkAndroidSurfaceCreateFlagsKHR
    -> VkAndroidSurfaceCreateFlagsKHR
    -> [VkAndroidSurfaceCreateFlagsKHR])
-> (VkAndroidSurfaceCreateFlagsKHR
    -> VkAndroidSurfaceCreateFlagsKHR
    -> VkAndroidSurfaceCreateFlagsKHR
    -> [VkAndroidSurfaceCreateFlagsKHR])
-> Enum VkAndroidSurfaceCreateFlagsKHR
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: VkAndroidSurfaceCreateFlagsKHR
-> VkAndroidSurfaceCreateFlagsKHR
-> VkAndroidSurfaceCreateFlagsKHR
-> [VkAndroidSurfaceCreateFlagsKHR]
$cenumFromThenTo :: VkAndroidSurfaceCreateFlagsKHR
-> VkAndroidSurfaceCreateFlagsKHR
-> VkAndroidSurfaceCreateFlagsKHR
-> [VkAndroidSurfaceCreateFlagsKHR]
enumFromTo :: VkAndroidSurfaceCreateFlagsKHR
-> VkAndroidSurfaceCreateFlagsKHR
-> [VkAndroidSurfaceCreateFlagsKHR]
$cenumFromTo :: VkAndroidSurfaceCreateFlagsKHR
-> VkAndroidSurfaceCreateFlagsKHR
-> [VkAndroidSurfaceCreateFlagsKHR]
enumFromThen :: VkAndroidSurfaceCreateFlagsKHR
-> VkAndroidSurfaceCreateFlagsKHR
-> [VkAndroidSurfaceCreateFlagsKHR]
$cenumFromThen :: VkAndroidSurfaceCreateFlagsKHR
-> VkAndroidSurfaceCreateFlagsKHR
-> [VkAndroidSurfaceCreateFlagsKHR]
enumFrom :: VkAndroidSurfaceCreateFlagsKHR -> [VkAndroidSurfaceCreateFlagsKHR]
$cenumFrom :: VkAndroidSurfaceCreateFlagsKHR -> [VkAndroidSurfaceCreateFlagsKHR]
fromEnum :: VkAndroidSurfaceCreateFlagsKHR -> Int
$cfromEnum :: VkAndroidSurfaceCreateFlagsKHR -> Int
toEnum :: Int -> VkAndroidSurfaceCreateFlagsKHR
$ctoEnum :: Int -> VkAndroidSurfaceCreateFlagsKHR
pred :: VkAndroidSurfaceCreateFlagsKHR -> VkAndroidSurfaceCreateFlagsKHR
$cpred :: VkAndroidSurfaceCreateFlagsKHR -> VkAndroidSurfaceCreateFlagsKHR
succ :: VkAndroidSurfaceCreateFlagsKHR -> VkAndroidSurfaceCreateFlagsKHR
$csucc :: VkAndroidSurfaceCreateFlagsKHR -> VkAndroidSurfaceCreateFlagsKHR
Enum, Eq VkAndroidSurfaceCreateFlagsKHR
VkAndroidSurfaceCreateFlagsKHR
Eq VkAndroidSurfaceCreateFlagsKHR
-> (VkAndroidSurfaceCreateFlagsKHR
    -> VkAndroidSurfaceCreateFlagsKHR
    -> VkAndroidSurfaceCreateFlagsKHR)
-> (VkAndroidSurfaceCreateFlagsKHR
    -> VkAndroidSurfaceCreateFlagsKHR
    -> VkAndroidSurfaceCreateFlagsKHR)
-> (VkAndroidSurfaceCreateFlagsKHR
    -> VkAndroidSurfaceCreateFlagsKHR
    -> VkAndroidSurfaceCreateFlagsKHR)
-> (VkAndroidSurfaceCreateFlagsKHR
    -> VkAndroidSurfaceCreateFlagsKHR)
-> (VkAndroidSurfaceCreateFlagsKHR
    -> Int -> VkAndroidSurfaceCreateFlagsKHR)
-> (VkAndroidSurfaceCreateFlagsKHR
    -> Int -> VkAndroidSurfaceCreateFlagsKHR)
-> VkAndroidSurfaceCreateFlagsKHR
-> (Int -> VkAndroidSurfaceCreateFlagsKHR)
-> (VkAndroidSurfaceCreateFlagsKHR
    -> Int -> VkAndroidSurfaceCreateFlagsKHR)
-> (VkAndroidSurfaceCreateFlagsKHR
    -> Int -> VkAndroidSurfaceCreateFlagsKHR)
-> (VkAndroidSurfaceCreateFlagsKHR
    -> Int -> VkAndroidSurfaceCreateFlagsKHR)
-> (VkAndroidSurfaceCreateFlagsKHR -> Int -> Bool)
-> (VkAndroidSurfaceCreateFlagsKHR -> Maybe Int)
-> (VkAndroidSurfaceCreateFlagsKHR -> Int)
-> (VkAndroidSurfaceCreateFlagsKHR -> Bool)
-> (VkAndroidSurfaceCreateFlagsKHR
    -> Int -> VkAndroidSurfaceCreateFlagsKHR)
-> (VkAndroidSurfaceCreateFlagsKHR
    -> Int -> VkAndroidSurfaceCreateFlagsKHR)
-> (VkAndroidSurfaceCreateFlagsKHR
    -> Int -> VkAndroidSurfaceCreateFlagsKHR)
-> (VkAndroidSurfaceCreateFlagsKHR
    -> Int -> VkAndroidSurfaceCreateFlagsKHR)
-> (VkAndroidSurfaceCreateFlagsKHR
    -> Int -> VkAndroidSurfaceCreateFlagsKHR)
-> (VkAndroidSurfaceCreateFlagsKHR
    -> Int -> VkAndroidSurfaceCreateFlagsKHR)
-> (VkAndroidSurfaceCreateFlagsKHR -> Int)
-> Bits VkAndroidSurfaceCreateFlagsKHR
Int -> VkAndroidSurfaceCreateFlagsKHR
VkAndroidSurfaceCreateFlagsKHR -> Bool
VkAndroidSurfaceCreateFlagsKHR -> Int
VkAndroidSurfaceCreateFlagsKHR -> Maybe Int
VkAndroidSurfaceCreateFlagsKHR -> VkAndroidSurfaceCreateFlagsKHR
VkAndroidSurfaceCreateFlagsKHR -> Int -> Bool
VkAndroidSurfaceCreateFlagsKHR
-> Int -> VkAndroidSurfaceCreateFlagsKHR
VkAndroidSurfaceCreateFlagsKHR
-> VkAndroidSurfaceCreateFlagsKHR -> VkAndroidSurfaceCreateFlagsKHR
forall a.
Eq a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
popCount :: VkAndroidSurfaceCreateFlagsKHR -> Int
$cpopCount :: VkAndroidSurfaceCreateFlagsKHR -> Int
rotateR :: VkAndroidSurfaceCreateFlagsKHR
-> Int -> VkAndroidSurfaceCreateFlagsKHR
$crotateR :: VkAndroidSurfaceCreateFlagsKHR
-> Int -> VkAndroidSurfaceCreateFlagsKHR
rotateL :: VkAndroidSurfaceCreateFlagsKHR
-> Int -> VkAndroidSurfaceCreateFlagsKHR
$crotateL :: VkAndroidSurfaceCreateFlagsKHR
-> Int -> VkAndroidSurfaceCreateFlagsKHR
unsafeShiftR :: VkAndroidSurfaceCreateFlagsKHR
-> Int -> VkAndroidSurfaceCreateFlagsKHR
$cunsafeShiftR :: VkAndroidSurfaceCreateFlagsKHR
-> Int -> VkAndroidSurfaceCreateFlagsKHR
shiftR :: VkAndroidSurfaceCreateFlagsKHR
-> Int -> VkAndroidSurfaceCreateFlagsKHR
$cshiftR :: VkAndroidSurfaceCreateFlagsKHR
-> Int -> VkAndroidSurfaceCreateFlagsKHR
unsafeShiftL :: VkAndroidSurfaceCreateFlagsKHR
-> Int -> VkAndroidSurfaceCreateFlagsKHR
$cunsafeShiftL :: VkAndroidSurfaceCreateFlagsKHR
-> Int -> VkAndroidSurfaceCreateFlagsKHR
shiftL :: VkAndroidSurfaceCreateFlagsKHR
-> Int -> VkAndroidSurfaceCreateFlagsKHR
$cshiftL :: VkAndroidSurfaceCreateFlagsKHR
-> Int -> VkAndroidSurfaceCreateFlagsKHR
isSigned :: VkAndroidSurfaceCreateFlagsKHR -> Bool
$cisSigned :: VkAndroidSurfaceCreateFlagsKHR -> Bool
bitSize :: VkAndroidSurfaceCreateFlagsKHR -> Int
$cbitSize :: VkAndroidSurfaceCreateFlagsKHR -> Int
bitSizeMaybe :: VkAndroidSurfaceCreateFlagsKHR -> Maybe Int
$cbitSizeMaybe :: VkAndroidSurfaceCreateFlagsKHR -> Maybe Int
testBit :: VkAndroidSurfaceCreateFlagsKHR -> Int -> Bool
$ctestBit :: VkAndroidSurfaceCreateFlagsKHR -> Int -> Bool
complementBit :: VkAndroidSurfaceCreateFlagsKHR
-> Int -> VkAndroidSurfaceCreateFlagsKHR
$ccomplementBit :: VkAndroidSurfaceCreateFlagsKHR
-> Int -> VkAndroidSurfaceCreateFlagsKHR
clearBit :: VkAndroidSurfaceCreateFlagsKHR
-> Int -> VkAndroidSurfaceCreateFlagsKHR
$cclearBit :: VkAndroidSurfaceCreateFlagsKHR
-> Int -> VkAndroidSurfaceCreateFlagsKHR
setBit :: VkAndroidSurfaceCreateFlagsKHR
-> Int -> VkAndroidSurfaceCreateFlagsKHR
$csetBit :: VkAndroidSurfaceCreateFlagsKHR
-> Int -> VkAndroidSurfaceCreateFlagsKHR
bit :: Int -> VkAndroidSurfaceCreateFlagsKHR
$cbit :: Int -> VkAndroidSurfaceCreateFlagsKHR
zeroBits :: VkAndroidSurfaceCreateFlagsKHR
$czeroBits :: VkAndroidSurfaceCreateFlagsKHR
rotate :: VkAndroidSurfaceCreateFlagsKHR
-> Int -> VkAndroidSurfaceCreateFlagsKHR
$crotate :: VkAndroidSurfaceCreateFlagsKHR
-> Int -> VkAndroidSurfaceCreateFlagsKHR
shift :: VkAndroidSurfaceCreateFlagsKHR
-> Int -> VkAndroidSurfaceCreateFlagsKHR
$cshift :: VkAndroidSurfaceCreateFlagsKHR
-> Int -> VkAndroidSurfaceCreateFlagsKHR
complement :: VkAndroidSurfaceCreateFlagsKHR -> VkAndroidSurfaceCreateFlagsKHR
$ccomplement :: VkAndroidSurfaceCreateFlagsKHR -> VkAndroidSurfaceCreateFlagsKHR
xor :: VkAndroidSurfaceCreateFlagsKHR
-> VkAndroidSurfaceCreateFlagsKHR -> VkAndroidSurfaceCreateFlagsKHR
$cxor :: VkAndroidSurfaceCreateFlagsKHR
-> VkAndroidSurfaceCreateFlagsKHR -> VkAndroidSurfaceCreateFlagsKHR
.|. :: VkAndroidSurfaceCreateFlagsKHR
-> VkAndroidSurfaceCreateFlagsKHR -> VkAndroidSurfaceCreateFlagsKHR
$c.|. :: VkAndroidSurfaceCreateFlagsKHR
-> VkAndroidSurfaceCreateFlagsKHR -> VkAndroidSurfaceCreateFlagsKHR
.&. :: VkAndroidSurfaceCreateFlagsKHR
-> VkAndroidSurfaceCreateFlagsKHR -> VkAndroidSurfaceCreateFlagsKHR
$c.&. :: VkAndroidSurfaceCreateFlagsKHR
-> VkAndroidSurfaceCreateFlagsKHR -> VkAndroidSurfaceCreateFlagsKHR
Bits, Bits VkAndroidSurfaceCreateFlagsKHR
Bits VkAndroidSurfaceCreateFlagsKHR
-> (VkAndroidSurfaceCreateFlagsKHR -> Int)
-> (VkAndroidSurfaceCreateFlagsKHR -> Int)
-> (VkAndroidSurfaceCreateFlagsKHR -> Int)
-> FiniteBits VkAndroidSurfaceCreateFlagsKHR
VkAndroidSurfaceCreateFlagsKHR -> Int
forall b.
Bits b -> (b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
countTrailingZeros :: VkAndroidSurfaceCreateFlagsKHR -> Int
$ccountTrailingZeros :: VkAndroidSurfaceCreateFlagsKHR -> Int
countLeadingZeros :: VkAndroidSurfaceCreateFlagsKHR -> Int
$ccountLeadingZeros :: VkAndroidSurfaceCreateFlagsKHR -> Int
finiteBitSize :: VkAndroidSurfaceCreateFlagsKHR -> Int
$cfiniteBitSize :: VkAndroidSurfaceCreateFlagsKHR -> Int
FiniteBits, Ptr VkAndroidSurfaceCreateFlagsKHR
-> IO VkAndroidSurfaceCreateFlagsKHR
Ptr VkAndroidSurfaceCreateFlagsKHR
-> Int -> IO VkAndroidSurfaceCreateFlagsKHR
Ptr VkAndroidSurfaceCreateFlagsKHR
-> Int -> VkAndroidSurfaceCreateFlagsKHR -> IO ()
Ptr VkAndroidSurfaceCreateFlagsKHR
-> VkAndroidSurfaceCreateFlagsKHR -> IO ()
VkAndroidSurfaceCreateFlagsKHR -> Int
(VkAndroidSurfaceCreateFlagsKHR -> Int)
-> (VkAndroidSurfaceCreateFlagsKHR -> Int)
-> (Ptr VkAndroidSurfaceCreateFlagsKHR
    -> Int -> IO VkAndroidSurfaceCreateFlagsKHR)
-> (Ptr VkAndroidSurfaceCreateFlagsKHR
    -> Int -> VkAndroidSurfaceCreateFlagsKHR -> IO ())
-> (forall b. Ptr b -> Int -> IO VkAndroidSurfaceCreateFlagsKHR)
-> (forall b.
    Ptr b -> Int -> VkAndroidSurfaceCreateFlagsKHR -> IO ())
-> (Ptr VkAndroidSurfaceCreateFlagsKHR
    -> IO VkAndroidSurfaceCreateFlagsKHR)
-> (Ptr VkAndroidSurfaceCreateFlagsKHR
    -> VkAndroidSurfaceCreateFlagsKHR -> IO ())
-> Storable VkAndroidSurfaceCreateFlagsKHR
forall b. Ptr b -> Int -> IO VkAndroidSurfaceCreateFlagsKHR
forall b. Ptr b -> Int -> VkAndroidSurfaceCreateFlagsKHR -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr VkAndroidSurfaceCreateFlagsKHR
-> VkAndroidSurfaceCreateFlagsKHR -> IO ()
$cpoke :: Ptr VkAndroidSurfaceCreateFlagsKHR
-> VkAndroidSurfaceCreateFlagsKHR -> IO ()
peek :: Ptr VkAndroidSurfaceCreateFlagsKHR
-> IO VkAndroidSurfaceCreateFlagsKHR
$cpeek :: Ptr VkAndroidSurfaceCreateFlagsKHR
-> IO VkAndroidSurfaceCreateFlagsKHR
pokeByteOff :: forall b. Ptr b -> Int -> VkAndroidSurfaceCreateFlagsKHR -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> VkAndroidSurfaceCreateFlagsKHR -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO VkAndroidSurfaceCreateFlagsKHR
$cpeekByteOff :: forall b. Ptr b -> Int -> IO VkAndroidSurfaceCreateFlagsKHR
pokeElemOff :: Ptr VkAndroidSurfaceCreateFlagsKHR
-> Int -> VkAndroidSurfaceCreateFlagsKHR -> IO ()
$cpokeElemOff :: Ptr VkAndroidSurfaceCreateFlagsKHR
-> Int -> VkAndroidSurfaceCreateFlagsKHR -> IO ()
peekElemOff :: Ptr VkAndroidSurfaceCreateFlagsKHR
-> Int -> IO VkAndroidSurfaceCreateFlagsKHR
$cpeekElemOff :: Ptr VkAndroidSurfaceCreateFlagsKHR
-> Int -> IO VkAndroidSurfaceCreateFlagsKHR
alignment :: VkAndroidSurfaceCreateFlagsKHR -> Int
$calignment :: VkAndroidSurfaceCreateFlagsKHR -> Int
sizeOf :: VkAndroidSurfaceCreateFlagsKHR -> Int
$csizeOf :: VkAndroidSurfaceCreateFlagsKHR -> Int
Storable)

instance Show VkAndroidSurfaceCreateFlagsKHR where
    {-# INLINE showsPrec #-}
    showsPrec :: Int -> VkAndroidSurfaceCreateFlagsKHR -> ShowS
showsPrec = (Int -> VkFlags -> ShowS)
-> Int -> VkAndroidSurfaceCreateFlagsKHR -> ShowS
coerce (Int -> VkFlags -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec :: Int -> VkFlags -> ShowS)

instance Read VkAndroidSurfaceCreateFlagsKHR where
    {-# INLINE readsPrec #-}
    readsPrec :: Int -> ReadS VkAndroidSurfaceCreateFlagsKHR
readsPrec = (Int -> ReadS VkFlags)
-> Int -> ReadS VkAndroidSurfaceCreateFlagsKHR
coerce (Int -> ReadS VkFlags
forall a. Read a => Int -> ReadS a
readsPrec :: Int -> ReadS VkFlags)

newtype VkBufferViewCreateFlags = VkBufferViewCreateFlags VkFlags
                                  deriving (VkBufferViewCreateFlags -> VkBufferViewCreateFlags -> Bool
(VkBufferViewCreateFlags -> VkBufferViewCreateFlags -> Bool)
-> (VkBufferViewCreateFlags -> VkBufferViewCreateFlags -> Bool)
-> Eq VkBufferViewCreateFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VkBufferViewCreateFlags -> VkBufferViewCreateFlags -> Bool
$c/= :: VkBufferViewCreateFlags -> VkBufferViewCreateFlags -> Bool
== :: VkBufferViewCreateFlags -> VkBufferViewCreateFlags -> Bool
$c== :: VkBufferViewCreateFlags -> VkBufferViewCreateFlags -> Bool
Eq, Eq VkBufferViewCreateFlags
Eq VkBufferViewCreateFlags
-> (VkBufferViewCreateFlags -> VkBufferViewCreateFlags -> Ordering)
-> (VkBufferViewCreateFlags -> VkBufferViewCreateFlags -> Bool)
-> (VkBufferViewCreateFlags -> VkBufferViewCreateFlags -> Bool)
-> (VkBufferViewCreateFlags -> VkBufferViewCreateFlags -> Bool)
-> (VkBufferViewCreateFlags -> VkBufferViewCreateFlags -> Bool)
-> (VkBufferViewCreateFlags
    -> VkBufferViewCreateFlags -> VkBufferViewCreateFlags)
-> (VkBufferViewCreateFlags
    -> VkBufferViewCreateFlags -> VkBufferViewCreateFlags)
-> Ord VkBufferViewCreateFlags
VkBufferViewCreateFlags -> VkBufferViewCreateFlags -> Bool
VkBufferViewCreateFlags -> VkBufferViewCreateFlags -> Ordering
VkBufferViewCreateFlags
-> VkBufferViewCreateFlags -> VkBufferViewCreateFlags
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: VkBufferViewCreateFlags
-> VkBufferViewCreateFlags -> VkBufferViewCreateFlags
$cmin :: VkBufferViewCreateFlags
-> VkBufferViewCreateFlags -> VkBufferViewCreateFlags
max :: VkBufferViewCreateFlags
-> VkBufferViewCreateFlags -> VkBufferViewCreateFlags
$cmax :: VkBufferViewCreateFlags
-> VkBufferViewCreateFlags -> VkBufferViewCreateFlags
>= :: VkBufferViewCreateFlags -> VkBufferViewCreateFlags -> Bool
$c>= :: VkBufferViewCreateFlags -> VkBufferViewCreateFlags -> Bool
> :: VkBufferViewCreateFlags -> VkBufferViewCreateFlags -> Bool
$c> :: VkBufferViewCreateFlags -> VkBufferViewCreateFlags -> Bool
<= :: VkBufferViewCreateFlags -> VkBufferViewCreateFlags -> Bool
$c<= :: VkBufferViewCreateFlags -> VkBufferViewCreateFlags -> Bool
< :: VkBufferViewCreateFlags -> VkBufferViewCreateFlags -> Bool
$c< :: VkBufferViewCreateFlags -> VkBufferViewCreateFlags -> Bool
compare :: VkBufferViewCreateFlags -> VkBufferViewCreateFlags -> Ordering
$ccompare :: VkBufferViewCreateFlags -> VkBufferViewCreateFlags -> Ordering
Ord, Int -> VkBufferViewCreateFlags
VkBufferViewCreateFlags -> Int
VkBufferViewCreateFlags -> [VkBufferViewCreateFlags]
VkBufferViewCreateFlags -> VkBufferViewCreateFlags
VkBufferViewCreateFlags
-> VkBufferViewCreateFlags -> [VkBufferViewCreateFlags]
VkBufferViewCreateFlags
-> VkBufferViewCreateFlags
-> VkBufferViewCreateFlags
-> [VkBufferViewCreateFlags]
(VkBufferViewCreateFlags -> VkBufferViewCreateFlags)
-> (VkBufferViewCreateFlags -> VkBufferViewCreateFlags)
-> (Int -> VkBufferViewCreateFlags)
-> (VkBufferViewCreateFlags -> Int)
-> (VkBufferViewCreateFlags -> [VkBufferViewCreateFlags])
-> (VkBufferViewCreateFlags
    -> VkBufferViewCreateFlags -> [VkBufferViewCreateFlags])
-> (VkBufferViewCreateFlags
    -> VkBufferViewCreateFlags -> [VkBufferViewCreateFlags])
-> (VkBufferViewCreateFlags
    -> VkBufferViewCreateFlags
    -> VkBufferViewCreateFlags
    -> [VkBufferViewCreateFlags])
-> Enum VkBufferViewCreateFlags
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: VkBufferViewCreateFlags
-> VkBufferViewCreateFlags
-> VkBufferViewCreateFlags
-> [VkBufferViewCreateFlags]
$cenumFromThenTo :: VkBufferViewCreateFlags
-> VkBufferViewCreateFlags
-> VkBufferViewCreateFlags
-> [VkBufferViewCreateFlags]
enumFromTo :: VkBufferViewCreateFlags
-> VkBufferViewCreateFlags -> [VkBufferViewCreateFlags]
$cenumFromTo :: VkBufferViewCreateFlags
-> VkBufferViewCreateFlags -> [VkBufferViewCreateFlags]
enumFromThen :: VkBufferViewCreateFlags
-> VkBufferViewCreateFlags -> [VkBufferViewCreateFlags]
$cenumFromThen :: VkBufferViewCreateFlags
-> VkBufferViewCreateFlags -> [VkBufferViewCreateFlags]
enumFrom :: VkBufferViewCreateFlags -> [VkBufferViewCreateFlags]
$cenumFrom :: VkBufferViewCreateFlags -> [VkBufferViewCreateFlags]
fromEnum :: VkBufferViewCreateFlags -> Int
$cfromEnum :: VkBufferViewCreateFlags -> Int
toEnum :: Int -> VkBufferViewCreateFlags
$ctoEnum :: Int -> VkBufferViewCreateFlags
pred :: VkBufferViewCreateFlags -> VkBufferViewCreateFlags
$cpred :: VkBufferViewCreateFlags -> VkBufferViewCreateFlags
succ :: VkBufferViewCreateFlags -> VkBufferViewCreateFlags
$csucc :: VkBufferViewCreateFlags -> VkBufferViewCreateFlags
Enum, Eq VkBufferViewCreateFlags
VkBufferViewCreateFlags
Eq VkBufferViewCreateFlags
-> (VkBufferViewCreateFlags
    -> VkBufferViewCreateFlags -> VkBufferViewCreateFlags)
-> (VkBufferViewCreateFlags
    -> VkBufferViewCreateFlags -> VkBufferViewCreateFlags)
-> (VkBufferViewCreateFlags
    -> VkBufferViewCreateFlags -> VkBufferViewCreateFlags)
-> (VkBufferViewCreateFlags -> VkBufferViewCreateFlags)
-> (VkBufferViewCreateFlags -> Int -> VkBufferViewCreateFlags)
-> (VkBufferViewCreateFlags -> Int -> VkBufferViewCreateFlags)
-> VkBufferViewCreateFlags
-> (Int -> VkBufferViewCreateFlags)
-> (VkBufferViewCreateFlags -> Int -> VkBufferViewCreateFlags)
-> (VkBufferViewCreateFlags -> Int -> VkBufferViewCreateFlags)
-> (VkBufferViewCreateFlags -> Int -> VkBufferViewCreateFlags)
-> (VkBufferViewCreateFlags -> Int -> Bool)
-> (VkBufferViewCreateFlags -> Maybe Int)
-> (VkBufferViewCreateFlags -> Int)
-> (VkBufferViewCreateFlags -> Bool)
-> (VkBufferViewCreateFlags -> Int -> VkBufferViewCreateFlags)
-> (VkBufferViewCreateFlags -> Int -> VkBufferViewCreateFlags)
-> (VkBufferViewCreateFlags -> Int -> VkBufferViewCreateFlags)
-> (VkBufferViewCreateFlags -> Int -> VkBufferViewCreateFlags)
-> (VkBufferViewCreateFlags -> Int -> VkBufferViewCreateFlags)
-> (VkBufferViewCreateFlags -> Int -> VkBufferViewCreateFlags)
-> (VkBufferViewCreateFlags -> Int)
-> Bits VkBufferViewCreateFlags
Int -> VkBufferViewCreateFlags
VkBufferViewCreateFlags -> Bool
VkBufferViewCreateFlags -> Int
VkBufferViewCreateFlags -> Maybe Int
VkBufferViewCreateFlags -> VkBufferViewCreateFlags
VkBufferViewCreateFlags -> Int -> Bool
VkBufferViewCreateFlags -> Int -> VkBufferViewCreateFlags
VkBufferViewCreateFlags
-> VkBufferViewCreateFlags -> VkBufferViewCreateFlags
forall a.
Eq a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
popCount :: VkBufferViewCreateFlags -> Int
$cpopCount :: VkBufferViewCreateFlags -> Int
rotateR :: VkBufferViewCreateFlags -> Int -> VkBufferViewCreateFlags
$crotateR :: VkBufferViewCreateFlags -> Int -> VkBufferViewCreateFlags
rotateL :: VkBufferViewCreateFlags -> Int -> VkBufferViewCreateFlags
$crotateL :: VkBufferViewCreateFlags -> Int -> VkBufferViewCreateFlags
unsafeShiftR :: VkBufferViewCreateFlags -> Int -> VkBufferViewCreateFlags
$cunsafeShiftR :: VkBufferViewCreateFlags -> Int -> VkBufferViewCreateFlags
shiftR :: VkBufferViewCreateFlags -> Int -> VkBufferViewCreateFlags
$cshiftR :: VkBufferViewCreateFlags -> Int -> VkBufferViewCreateFlags
unsafeShiftL :: VkBufferViewCreateFlags -> Int -> VkBufferViewCreateFlags
$cunsafeShiftL :: VkBufferViewCreateFlags -> Int -> VkBufferViewCreateFlags
shiftL :: VkBufferViewCreateFlags -> Int -> VkBufferViewCreateFlags
$cshiftL :: VkBufferViewCreateFlags -> Int -> VkBufferViewCreateFlags
isSigned :: VkBufferViewCreateFlags -> Bool
$cisSigned :: VkBufferViewCreateFlags -> Bool
bitSize :: VkBufferViewCreateFlags -> Int
$cbitSize :: VkBufferViewCreateFlags -> Int
bitSizeMaybe :: VkBufferViewCreateFlags -> Maybe Int
$cbitSizeMaybe :: VkBufferViewCreateFlags -> Maybe Int
testBit :: VkBufferViewCreateFlags -> Int -> Bool
$ctestBit :: VkBufferViewCreateFlags -> Int -> Bool
complementBit :: VkBufferViewCreateFlags -> Int -> VkBufferViewCreateFlags
$ccomplementBit :: VkBufferViewCreateFlags -> Int -> VkBufferViewCreateFlags
clearBit :: VkBufferViewCreateFlags -> Int -> VkBufferViewCreateFlags
$cclearBit :: VkBufferViewCreateFlags -> Int -> VkBufferViewCreateFlags
setBit :: VkBufferViewCreateFlags -> Int -> VkBufferViewCreateFlags
$csetBit :: VkBufferViewCreateFlags -> Int -> VkBufferViewCreateFlags
bit :: Int -> VkBufferViewCreateFlags
$cbit :: Int -> VkBufferViewCreateFlags
zeroBits :: VkBufferViewCreateFlags
$czeroBits :: VkBufferViewCreateFlags
rotate :: VkBufferViewCreateFlags -> Int -> VkBufferViewCreateFlags
$crotate :: VkBufferViewCreateFlags -> Int -> VkBufferViewCreateFlags
shift :: VkBufferViewCreateFlags -> Int -> VkBufferViewCreateFlags
$cshift :: VkBufferViewCreateFlags -> Int -> VkBufferViewCreateFlags
complement :: VkBufferViewCreateFlags -> VkBufferViewCreateFlags
$ccomplement :: VkBufferViewCreateFlags -> VkBufferViewCreateFlags
xor :: VkBufferViewCreateFlags
-> VkBufferViewCreateFlags -> VkBufferViewCreateFlags
$cxor :: VkBufferViewCreateFlags
-> VkBufferViewCreateFlags -> VkBufferViewCreateFlags
.|. :: VkBufferViewCreateFlags
-> VkBufferViewCreateFlags -> VkBufferViewCreateFlags
$c.|. :: VkBufferViewCreateFlags
-> VkBufferViewCreateFlags -> VkBufferViewCreateFlags
.&. :: VkBufferViewCreateFlags
-> VkBufferViewCreateFlags -> VkBufferViewCreateFlags
$c.&. :: VkBufferViewCreateFlags
-> VkBufferViewCreateFlags -> VkBufferViewCreateFlags
Bits, Bits VkBufferViewCreateFlags
Bits VkBufferViewCreateFlags
-> (VkBufferViewCreateFlags -> Int)
-> (VkBufferViewCreateFlags -> Int)
-> (VkBufferViewCreateFlags -> Int)
-> FiniteBits VkBufferViewCreateFlags
VkBufferViewCreateFlags -> Int
forall b.
Bits b -> (b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
countTrailingZeros :: VkBufferViewCreateFlags -> Int
$ccountTrailingZeros :: VkBufferViewCreateFlags -> Int
countLeadingZeros :: VkBufferViewCreateFlags -> Int
$ccountLeadingZeros :: VkBufferViewCreateFlags -> Int
finiteBitSize :: VkBufferViewCreateFlags -> Int
$cfiniteBitSize :: VkBufferViewCreateFlags -> Int
FiniteBits, Ptr VkBufferViewCreateFlags -> IO VkBufferViewCreateFlags
Ptr VkBufferViewCreateFlags -> Int -> IO VkBufferViewCreateFlags
Ptr VkBufferViewCreateFlags
-> Int -> VkBufferViewCreateFlags -> IO ()
Ptr VkBufferViewCreateFlags -> VkBufferViewCreateFlags -> IO ()
VkBufferViewCreateFlags -> Int
(VkBufferViewCreateFlags -> Int)
-> (VkBufferViewCreateFlags -> Int)
-> (Ptr VkBufferViewCreateFlags
    -> Int -> IO VkBufferViewCreateFlags)
-> (Ptr VkBufferViewCreateFlags
    -> Int -> VkBufferViewCreateFlags -> IO ())
-> (forall b. Ptr b -> Int -> IO VkBufferViewCreateFlags)
-> (forall b. Ptr b -> Int -> VkBufferViewCreateFlags -> IO ())
-> (Ptr VkBufferViewCreateFlags -> IO VkBufferViewCreateFlags)
-> (Ptr VkBufferViewCreateFlags
    -> VkBufferViewCreateFlags -> IO ())
-> Storable VkBufferViewCreateFlags
forall b. Ptr b -> Int -> IO VkBufferViewCreateFlags
forall b. Ptr b -> Int -> VkBufferViewCreateFlags -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr VkBufferViewCreateFlags -> VkBufferViewCreateFlags -> IO ()
$cpoke :: Ptr VkBufferViewCreateFlags -> VkBufferViewCreateFlags -> IO ()
peek :: Ptr VkBufferViewCreateFlags -> IO VkBufferViewCreateFlags
$cpeek :: Ptr VkBufferViewCreateFlags -> IO VkBufferViewCreateFlags
pokeByteOff :: forall b. Ptr b -> Int -> VkBufferViewCreateFlags -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> VkBufferViewCreateFlags -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO VkBufferViewCreateFlags
$cpeekByteOff :: forall b. Ptr b -> Int -> IO VkBufferViewCreateFlags
pokeElemOff :: Ptr VkBufferViewCreateFlags
-> Int -> VkBufferViewCreateFlags -> IO ()
$cpokeElemOff :: Ptr VkBufferViewCreateFlags
-> Int -> VkBufferViewCreateFlags -> IO ()
peekElemOff :: Ptr VkBufferViewCreateFlags -> Int -> IO VkBufferViewCreateFlags
$cpeekElemOff :: Ptr VkBufferViewCreateFlags -> Int -> IO VkBufferViewCreateFlags
alignment :: VkBufferViewCreateFlags -> Int
$calignment :: VkBufferViewCreateFlags -> Int
sizeOf :: VkBufferViewCreateFlags -> Int
$csizeOf :: VkBufferViewCreateFlags -> Int
Storable)

instance Show VkBufferViewCreateFlags where
    {-# INLINE showsPrec #-}
    showsPrec :: Int -> VkBufferViewCreateFlags -> ShowS
showsPrec = (Int -> VkFlags -> ShowS)
-> Int -> VkBufferViewCreateFlags -> ShowS
coerce (Int -> VkFlags -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec :: Int -> VkFlags -> ShowS)

instance Read VkBufferViewCreateFlags where
    {-# INLINE readsPrec #-}
    readsPrec :: Int -> ReadS VkBufferViewCreateFlags
readsPrec = (Int -> ReadS VkFlags) -> Int -> ReadS VkBufferViewCreateFlags
coerce (Int -> ReadS VkFlags
forall a. Read a => Int -> ReadS a
readsPrec :: Int -> ReadS VkFlags)

newtype VkBuildAccelerationStructureFlagsNV = VkBuildAccelerationStructureFlagsNV VkFlags
                                              deriving (VkBuildAccelerationStructureFlagsNV
-> VkBuildAccelerationStructureFlagsNV -> Bool
(VkBuildAccelerationStructureFlagsNV
 -> VkBuildAccelerationStructureFlagsNV -> Bool)
-> (VkBuildAccelerationStructureFlagsNV
    -> VkBuildAccelerationStructureFlagsNV -> Bool)
-> Eq VkBuildAccelerationStructureFlagsNV
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VkBuildAccelerationStructureFlagsNV
-> VkBuildAccelerationStructureFlagsNV -> Bool
$c/= :: VkBuildAccelerationStructureFlagsNV
-> VkBuildAccelerationStructureFlagsNV -> Bool
== :: VkBuildAccelerationStructureFlagsNV
-> VkBuildAccelerationStructureFlagsNV -> Bool
$c== :: VkBuildAccelerationStructureFlagsNV
-> VkBuildAccelerationStructureFlagsNV -> Bool
Eq, Eq VkBuildAccelerationStructureFlagsNV
Eq VkBuildAccelerationStructureFlagsNV
-> (VkBuildAccelerationStructureFlagsNV
    -> VkBuildAccelerationStructureFlagsNV -> Ordering)
-> (VkBuildAccelerationStructureFlagsNV
    -> VkBuildAccelerationStructureFlagsNV -> Bool)
-> (VkBuildAccelerationStructureFlagsNV
    -> VkBuildAccelerationStructureFlagsNV -> Bool)
-> (VkBuildAccelerationStructureFlagsNV
    -> VkBuildAccelerationStructureFlagsNV -> Bool)
-> (VkBuildAccelerationStructureFlagsNV
    -> VkBuildAccelerationStructureFlagsNV -> Bool)
-> (VkBuildAccelerationStructureFlagsNV
    -> VkBuildAccelerationStructureFlagsNV
    -> VkBuildAccelerationStructureFlagsNV)
-> (VkBuildAccelerationStructureFlagsNV
    -> VkBuildAccelerationStructureFlagsNV
    -> VkBuildAccelerationStructureFlagsNV)
-> Ord VkBuildAccelerationStructureFlagsNV
VkBuildAccelerationStructureFlagsNV
-> VkBuildAccelerationStructureFlagsNV -> Bool
VkBuildAccelerationStructureFlagsNV
-> VkBuildAccelerationStructureFlagsNV -> Ordering
VkBuildAccelerationStructureFlagsNV
-> VkBuildAccelerationStructureFlagsNV
-> VkBuildAccelerationStructureFlagsNV
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: VkBuildAccelerationStructureFlagsNV
-> VkBuildAccelerationStructureFlagsNV
-> VkBuildAccelerationStructureFlagsNV
$cmin :: VkBuildAccelerationStructureFlagsNV
-> VkBuildAccelerationStructureFlagsNV
-> VkBuildAccelerationStructureFlagsNV
max :: VkBuildAccelerationStructureFlagsNV
-> VkBuildAccelerationStructureFlagsNV
-> VkBuildAccelerationStructureFlagsNV
$cmax :: VkBuildAccelerationStructureFlagsNV
-> VkBuildAccelerationStructureFlagsNV
-> VkBuildAccelerationStructureFlagsNV
>= :: VkBuildAccelerationStructureFlagsNV
-> VkBuildAccelerationStructureFlagsNV -> Bool
$c>= :: VkBuildAccelerationStructureFlagsNV
-> VkBuildAccelerationStructureFlagsNV -> Bool
> :: VkBuildAccelerationStructureFlagsNV
-> VkBuildAccelerationStructureFlagsNV -> Bool
$c> :: VkBuildAccelerationStructureFlagsNV
-> VkBuildAccelerationStructureFlagsNV -> Bool
<= :: VkBuildAccelerationStructureFlagsNV
-> VkBuildAccelerationStructureFlagsNV -> Bool
$c<= :: VkBuildAccelerationStructureFlagsNV
-> VkBuildAccelerationStructureFlagsNV -> Bool
< :: VkBuildAccelerationStructureFlagsNV
-> VkBuildAccelerationStructureFlagsNV -> Bool
$c< :: VkBuildAccelerationStructureFlagsNV
-> VkBuildAccelerationStructureFlagsNV -> Bool
compare :: VkBuildAccelerationStructureFlagsNV
-> VkBuildAccelerationStructureFlagsNV -> Ordering
$ccompare :: VkBuildAccelerationStructureFlagsNV
-> VkBuildAccelerationStructureFlagsNV -> Ordering
Ord, Int -> VkBuildAccelerationStructureFlagsNV
VkBuildAccelerationStructureFlagsNV -> Int
VkBuildAccelerationStructureFlagsNV
-> [VkBuildAccelerationStructureFlagsNV]
VkBuildAccelerationStructureFlagsNV
-> VkBuildAccelerationStructureFlagsNV
VkBuildAccelerationStructureFlagsNV
-> VkBuildAccelerationStructureFlagsNV
-> [VkBuildAccelerationStructureFlagsNV]
VkBuildAccelerationStructureFlagsNV
-> VkBuildAccelerationStructureFlagsNV
-> VkBuildAccelerationStructureFlagsNV
-> [VkBuildAccelerationStructureFlagsNV]
(VkBuildAccelerationStructureFlagsNV
 -> VkBuildAccelerationStructureFlagsNV)
-> (VkBuildAccelerationStructureFlagsNV
    -> VkBuildAccelerationStructureFlagsNV)
-> (Int -> VkBuildAccelerationStructureFlagsNV)
-> (VkBuildAccelerationStructureFlagsNV -> Int)
-> (VkBuildAccelerationStructureFlagsNV
    -> [VkBuildAccelerationStructureFlagsNV])
-> (VkBuildAccelerationStructureFlagsNV
    -> VkBuildAccelerationStructureFlagsNV
    -> [VkBuildAccelerationStructureFlagsNV])
-> (VkBuildAccelerationStructureFlagsNV
    -> VkBuildAccelerationStructureFlagsNV
    -> [VkBuildAccelerationStructureFlagsNV])
-> (VkBuildAccelerationStructureFlagsNV
    -> VkBuildAccelerationStructureFlagsNV
    -> VkBuildAccelerationStructureFlagsNV
    -> [VkBuildAccelerationStructureFlagsNV])
-> Enum VkBuildAccelerationStructureFlagsNV
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: VkBuildAccelerationStructureFlagsNV
-> VkBuildAccelerationStructureFlagsNV
-> VkBuildAccelerationStructureFlagsNV
-> [VkBuildAccelerationStructureFlagsNV]
$cenumFromThenTo :: VkBuildAccelerationStructureFlagsNV
-> VkBuildAccelerationStructureFlagsNV
-> VkBuildAccelerationStructureFlagsNV
-> [VkBuildAccelerationStructureFlagsNV]
enumFromTo :: VkBuildAccelerationStructureFlagsNV
-> VkBuildAccelerationStructureFlagsNV
-> [VkBuildAccelerationStructureFlagsNV]
$cenumFromTo :: VkBuildAccelerationStructureFlagsNV
-> VkBuildAccelerationStructureFlagsNV
-> [VkBuildAccelerationStructureFlagsNV]
enumFromThen :: VkBuildAccelerationStructureFlagsNV
-> VkBuildAccelerationStructureFlagsNV
-> [VkBuildAccelerationStructureFlagsNV]
$cenumFromThen :: VkBuildAccelerationStructureFlagsNV
-> VkBuildAccelerationStructureFlagsNV
-> [VkBuildAccelerationStructureFlagsNV]
enumFrom :: VkBuildAccelerationStructureFlagsNV
-> [VkBuildAccelerationStructureFlagsNV]
$cenumFrom :: VkBuildAccelerationStructureFlagsNV
-> [VkBuildAccelerationStructureFlagsNV]
fromEnum :: VkBuildAccelerationStructureFlagsNV -> Int
$cfromEnum :: VkBuildAccelerationStructureFlagsNV -> Int
toEnum :: Int -> VkBuildAccelerationStructureFlagsNV
$ctoEnum :: Int -> VkBuildAccelerationStructureFlagsNV
pred :: VkBuildAccelerationStructureFlagsNV
-> VkBuildAccelerationStructureFlagsNV
$cpred :: VkBuildAccelerationStructureFlagsNV
-> VkBuildAccelerationStructureFlagsNV
succ :: VkBuildAccelerationStructureFlagsNV
-> VkBuildAccelerationStructureFlagsNV
$csucc :: VkBuildAccelerationStructureFlagsNV
-> VkBuildAccelerationStructureFlagsNV
Enum, Eq VkBuildAccelerationStructureFlagsNV
VkBuildAccelerationStructureFlagsNV
Eq VkBuildAccelerationStructureFlagsNV
-> (VkBuildAccelerationStructureFlagsNV
    -> VkBuildAccelerationStructureFlagsNV
    -> VkBuildAccelerationStructureFlagsNV)
-> (VkBuildAccelerationStructureFlagsNV
    -> VkBuildAccelerationStructureFlagsNV
    -> VkBuildAccelerationStructureFlagsNV)
-> (VkBuildAccelerationStructureFlagsNV
    -> VkBuildAccelerationStructureFlagsNV
    -> VkBuildAccelerationStructureFlagsNV)
-> (VkBuildAccelerationStructureFlagsNV
    -> VkBuildAccelerationStructureFlagsNV)
-> (VkBuildAccelerationStructureFlagsNV
    -> Int -> VkBuildAccelerationStructureFlagsNV)
-> (VkBuildAccelerationStructureFlagsNV
    -> Int -> VkBuildAccelerationStructureFlagsNV)
-> VkBuildAccelerationStructureFlagsNV
-> (Int -> VkBuildAccelerationStructureFlagsNV)
-> (VkBuildAccelerationStructureFlagsNV
    -> Int -> VkBuildAccelerationStructureFlagsNV)
-> (VkBuildAccelerationStructureFlagsNV
    -> Int -> VkBuildAccelerationStructureFlagsNV)
-> (VkBuildAccelerationStructureFlagsNV
    -> Int -> VkBuildAccelerationStructureFlagsNV)
-> (VkBuildAccelerationStructureFlagsNV -> Int -> Bool)
-> (VkBuildAccelerationStructureFlagsNV -> Maybe Int)
-> (VkBuildAccelerationStructureFlagsNV -> Int)
-> (VkBuildAccelerationStructureFlagsNV -> Bool)
-> (VkBuildAccelerationStructureFlagsNV
    -> Int -> VkBuildAccelerationStructureFlagsNV)
-> (VkBuildAccelerationStructureFlagsNV
    -> Int -> VkBuildAccelerationStructureFlagsNV)
-> (VkBuildAccelerationStructureFlagsNV
    -> Int -> VkBuildAccelerationStructureFlagsNV)
-> (VkBuildAccelerationStructureFlagsNV
    -> Int -> VkBuildAccelerationStructureFlagsNV)
-> (VkBuildAccelerationStructureFlagsNV
    -> Int -> VkBuildAccelerationStructureFlagsNV)
-> (VkBuildAccelerationStructureFlagsNV
    -> Int -> VkBuildAccelerationStructureFlagsNV)
-> (VkBuildAccelerationStructureFlagsNV -> Int)
-> Bits VkBuildAccelerationStructureFlagsNV
Int -> VkBuildAccelerationStructureFlagsNV
VkBuildAccelerationStructureFlagsNV -> Bool
VkBuildAccelerationStructureFlagsNV -> Int
VkBuildAccelerationStructureFlagsNV -> Maybe Int
VkBuildAccelerationStructureFlagsNV
-> VkBuildAccelerationStructureFlagsNV
VkBuildAccelerationStructureFlagsNV -> Int -> Bool
VkBuildAccelerationStructureFlagsNV
-> Int -> VkBuildAccelerationStructureFlagsNV
VkBuildAccelerationStructureFlagsNV
-> VkBuildAccelerationStructureFlagsNV
-> VkBuildAccelerationStructureFlagsNV
forall a.
Eq a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
popCount :: VkBuildAccelerationStructureFlagsNV -> Int
$cpopCount :: VkBuildAccelerationStructureFlagsNV -> Int
rotateR :: VkBuildAccelerationStructureFlagsNV
-> Int -> VkBuildAccelerationStructureFlagsNV
$crotateR :: VkBuildAccelerationStructureFlagsNV
-> Int -> VkBuildAccelerationStructureFlagsNV
rotateL :: VkBuildAccelerationStructureFlagsNV
-> Int -> VkBuildAccelerationStructureFlagsNV
$crotateL :: VkBuildAccelerationStructureFlagsNV
-> Int -> VkBuildAccelerationStructureFlagsNV
unsafeShiftR :: VkBuildAccelerationStructureFlagsNV
-> Int -> VkBuildAccelerationStructureFlagsNV
$cunsafeShiftR :: VkBuildAccelerationStructureFlagsNV
-> Int -> VkBuildAccelerationStructureFlagsNV
shiftR :: VkBuildAccelerationStructureFlagsNV
-> Int -> VkBuildAccelerationStructureFlagsNV
$cshiftR :: VkBuildAccelerationStructureFlagsNV
-> Int -> VkBuildAccelerationStructureFlagsNV
unsafeShiftL :: VkBuildAccelerationStructureFlagsNV
-> Int -> VkBuildAccelerationStructureFlagsNV
$cunsafeShiftL :: VkBuildAccelerationStructureFlagsNV
-> Int -> VkBuildAccelerationStructureFlagsNV
shiftL :: VkBuildAccelerationStructureFlagsNV
-> Int -> VkBuildAccelerationStructureFlagsNV
$cshiftL :: VkBuildAccelerationStructureFlagsNV
-> Int -> VkBuildAccelerationStructureFlagsNV
isSigned :: VkBuildAccelerationStructureFlagsNV -> Bool
$cisSigned :: VkBuildAccelerationStructureFlagsNV -> Bool
bitSize :: VkBuildAccelerationStructureFlagsNV -> Int
$cbitSize :: VkBuildAccelerationStructureFlagsNV -> Int
bitSizeMaybe :: VkBuildAccelerationStructureFlagsNV -> Maybe Int
$cbitSizeMaybe :: VkBuildAccelerationStructureFlagsNV -> Maybe Int
testBit :: VkBuildAccelerationStructureFlagsNV -> Int -> Bool
$ctestBit :: VkBuildAccelerationStructureFlagsNV -> Int -> Bool
complementBit :: VkBuildAccelerationStructureFlagsNV
-> Int -> VkBuildAccelerationStructureFlagsNV
$ccomplementBit :: VkBuildAccelerationStructureFlagsNV
-> Int -> VkBuildAccelerationStructureFlagsNV
clearBit :: VkBuildAccelerationStructureFlagsNV
-> Int -> VkBuildAccelerationStructureFlagsNV
$cclearBit :: VkBuildAccelerationStructureFlagsNV
-> Int -> VkBuildAccelerationStructureFlagsNV
setBit :: VkBuildAccelerationStructureFlagsNV
-> Int -> VkBuildAccelerationStructureFlagsNV
$csetBit :: VkBuildAccelerationStructureFlagsNV
-> Int -> VkBuildAccelerationStructureFlagsNV
bit :: Int -> VkBuildAccelerationStructureFlagsNV
$cbit :: Int -> VkBuildAccelerationStructureFlagsNV
zeroBits :: VkBuildAccelerationStructureFlagsNV
$czeroBits :: VkBuildAccelerationStructureFlagsNV
rotate :: VkBuildAccelerationStructureFlagsNV
-> Int -> VkBuildAccelerationStructureFlagsNV
$crotate :: VkBuildAccelerationStructureFlagsNV
-> Int -> VkBuildAccelerationStructureFlagsNV
shift :: VkBuildAccelerationStructureFlagsNV
-> Int -> VkBuildAccelerationStructureFlagsNV
$cshift :: VkBuildAccelerationStructureFlagsNV
-> Int -> VkBuildAccelerationStructureFlagsNV
complement :: VkBuildAccelerationStructureFlagsNV
-> VkBuildAccelerationStructureFlagsNV
$ccomplement :: VkBuildAccelerationStructureFlagsNV
-> VkBuildAccelerationStructureFlagsNV
xor :: VkBuildAccelerationStructureFlagsNV
-> VkBuildAccelerationStructureFlagsNV
-> VkBuildAccelerationStructureFlagsNV
$cxor :: VkBuildAccelerationStructureFlagsNV
-> VkBuildAccelerationStructureFlagsNV
-> VkBuildAccelerationStructureFlagsNV
.|. :: VkBuildAccelerationStructureFlagsNV
-> VkBuildAccelerationStructureFlagsNV
-> VkBuildAccelerationStructureFlagsNV
$c.|. :: VkBuildAccelerationStructureFlagsNV
-> VkBuildAccelerationStructureFlagsNV
-> VkBuildAccelerationStructureFlagsNV
.&. :: VkBuildAccelerationStructureFlagsNV
-> VkBuildAccelerationStructureFlagsNV
-> VkBuildAccelerationStructureFlagsNV
$c.&. :: VkBuildAccelerationStructureFlagsNV
-> VkBuildAccelerationStructureFlagsNV
-> VkBuildAccelerationStructureFlagsNV
Bits, Bits VkBuildAccelerationStructureFlagsNV
Bits VkBuildAccelerationStructureFlagsNV
-> (VkBuildAccelerationStructureFlagsNV -> Int)
-> (VkBuildAccelerationStructureFlagsNV -> Int)
-> (VkBuildAccelerationStructureFlagsNV -> Int)
-> FiniteBits VkBuildAccelerationStructureFlagsNV
VkBuildAccelerationStructureFlagsNV -> Int
forall b.
Bits b -> (b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
countTrailingZeros :: VkBuildAccelerationStructureFlagsNV -> Int
$ccountTrailingZeros :: VkBuildAccelerationStructureFlagsNV -> Int
countLeadingZeros :: VkBuildAccelerationStructureFlagsNV -> Int
$ccountLeadingZeros :: VkBuildAccelerationStructureFlagsNV -> Int
finiteBitSize :: VkBuildAccelerationStructureFlagsNV -> Int
$cfiniteBitSize :: VkBuildAccelerationStructureFlagsNV -> Int
FiniteBits, Ptr VkBuildAccelerationStructureFlagsNV
-> IO VkBuildAccelerationStructureFlagsNV
Ptr VkBuildAccelerationStructureFlagsNV
-> Int -> IO VkBuildAccelerationStructureFlagsNV
Ptr VkBuildAccelerationStructureFlagsNV
-> Int -> VkBuildAccelerationStructureFlagsNV -> IO ()
Ptr VkBuildAccelerationStructureFlagsNV
-> VkBuildAccelerationStructureFlagsNV -> IO ()
VkBuildAccelerationStructureFlagsNV -> Int
(VkBuildAccelerationStructureFlagsNV -> Int)
-> (VkBuildAccelerationStructureFlagsNV -> Int)
-> (Ptr VkBuildAccelerationStructureFlagsNV
    -> Int -> IO VkBuildAccelerationStructureFlagsNV)
-> (Ptr VkBuildAccelerationStructureFlagsNV
    -> Int -> VkBuildAccelerationStructureFlagsNV -> IO ())
-> (forall b.
    Ptr b -> Int -> IO VkBuildAccelerationStructureFlagsNV)
-> (forall b.
    Ptr b -> Int -> VkBuildAccelerationStructureFlagsNV -> IO ())
-> (Ptr VkBuildAccelerationStructureFlagsNV
    -> IO VkBuildAccelerationStructureFlagsNV)
-> (Ptr VkBuildAccelerationStructureFlagsNV
    -> VkBuildAccelerationStructureFlagsNV -> IO ())
-> Storable VkBuildAccelerationStructureFlagsNV
forall b. Ptr b -> Int -> IO VkBuildAccelerationStructureFlagsNV
forall b.
Ptr b -> Int -> VkBuildAccelerationStructureFlagsNV -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr VkBuildAccelerationStructureFlagsNV
-> VkBuildAccelerationStructureFlagsNV -> IO ()
$cpoke :: Ptr VkBuildAccelerationStructureFlagsNV
-> VkBuildAccelerationStructureFlagsNV -> IO ()
peek :: Ptr VkBuildAccelerationStructureFlagsNV
-> IO VkBuildAccelerationStructureFlagsNV
$cpeek :: Ptr VkBuildAccelerationStructureFlagsNV
-> IO VkBuildAccelerationStructureFlagsNV
pokeByteOff :: forall b.
Ptr b -> Int -> VkBuildAccelerationStructureFlagsNV -> IO ()
$cpokeByteOff :: forall b.
Ptr b -> Int -> VkBuildAccelerationStructureFlagsNV -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO VkBuildAccelerationStructureFlagsNV
$cpeekByteOff :: forall b. Ptr b -> Int -> IO VkBuildAccelerationStructureFlagsNV
pokeElemOff :: Ptr VkBuildAccelerationStructureFlagsNV
-> Int -> VkBuildAccelerationStructureFlagsNV -> IO ()
$cpokeElemOff :: Ptr VkBuildAccelerationStructureFlagsNV
-> Int -> VkBuildAccelerationStructureFlagsNV -> IO ()
peekElemOff :: Ptr VkBuildAccelerationStructureFlagsNV
-> Int -> IO VkBuildAccelerationStructureFlagsNV
$cpeekElemOff :: Ptr VkBuildAccelerationStructureFlagsNV
-> Int -> IO VkBuildAccelerationStructureFlagsNV
alignment :: VkBuildAccelerationStructureFlagsNV -> Int
$calignment :: VkBuildAccelerationStructureFlagsNV -> Int
sizeOf :: VkBuildAccelerationStructureFlagsNV -> Int
$csizeOf :: VkBuildAccelerationStructureFlagsNV -> Int
Storable)

instance Show VkBuildAccelerationStructureFlagsNV where
    {-# INLINE showsPrec #-}
    showsPrec :: Int -> VkBuildAccelerationStructureFlagsNV -> ShowS
showsPrec = (Int -> VkFlags -> ShowS)
-> Int -> VkBuildAccelerationStructureFlagsNV -> ShowS
coerce (Int -> VkFlags -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec :: Int -> VkFlags -> ShowS)

instance Read VkBuildAccelerationStructureFlagsNV where
    {-# INLINE readsPrec #-}
    readsPrec :: Int -> ReadS VkBuildAccelerationStructureFlagsNV
readsPrec = (Int -> ReadS VkFlags)
-> Int -> ReadS VkBuildAccelerationStructureFlagsNV
coerce (Int -> ReadS VkFlags
forall a. Read a => Int -> ReadS a
readsPrec :: Int -> ReadS VkFlags)

newtype VkCommandPoolTrimFlags = VkCommandPoolTrimFlags VkFlags
                                 deriving (VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags -> Bool
(VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags -> Bool)
-> (VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags -> Bool)
-> Eq VkCommandPoolTrimFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags -> Bool
$c/= :: VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags -> Bool
== :: VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags -> Bool
$c== :: VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags -> Bool
Eq, Eq VkCommandPoolTrimFlags
Eq VkCommandPoolTrimFlags
-> (VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags -> Ordering)
-> (VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags -> Bool)
-> (VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags -> Bool)
-> (VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags -> Bool)
-> (VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags -> Bool)
-> (VkCommandPoolTrimFlags
    -> VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags)
-> (VkCommandPoolTrimFlags
    -> VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags)
-> Ord VkCommandPoolTrimFlags
VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags -> Bool
VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags -> Ordering
VkCommandPoolTrimFlags
-> VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: VkCommandPoolTrimFlags
-> VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags
$cmin :: VkCommandPoolTrimFlags
-> VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags
max :: VkCommandPoolTrimFlags
-> VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags
$cmax :: VkCommandPoolTrimFlags
-> VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags
>= :: VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags -> Bool
$c>= :: VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags -> Bool
> :: VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags -> Bool
$c> :: VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags -> Bool
<= :: VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags -> Bool
$c<= :: VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags -> Bool
< :: VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags -> Bool
$c< :: VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags -> Bool
compare :: VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags -> Ordering
$ccompare :: VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags -> Ordering
Ord, Int -> VkCommandPoolTrimFlags
VkCommandPoolTrimFlags -> Int
VkCommandPoolTrimFlags -> [VkCommandPoolTrimFlags]
VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags
VkCommandPoolTrimFlags
-> VkCommandPoolTrimFlags -> [VkCommandPoolTrimFlags]
VkCommandPoolTrimFlags
-> VkCommandPoolTrimFlags
-> VkCommandPoolTrimFlags
-> [VkCommandPoolTrimFlags]
(VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags)
-> (VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags)
-> (Int -> VkCommandPoolTrimFlags)
-> (VkCommandPoolTrimFlags -> Int)
-> (VkCommandPoolTrimFlags -> [VkCommandPoolTrimFlags])
-> (VkCommandPoolTrimFlags
    -> VkCommandPoolTrimFlags -> [VkCommandPoolTrimFlags])
-> (VkCommandPoolTrimFlags
    -> VkCommandPoolTrimFlags -> [VkCommandPoolTrimFlags])
-> (VkCommandPoolTrimFlags
    -> VkCommandPoolTrimFlags
    -> VkCommandPoolTrimFlags
    -> [VkCommandPoolTrimFlags])
-> Enum VkCommandPoolTrimFlags
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: VkCommandPoolTrimFlags
-> VkCommandPoolTrimFlags
-> VkCommandPoolTrimFlags
-> [VkCommandPoolTrimFlags]
$cenumFromThenTo :: VkCommandPoolTrimFlags
-> VkCommandPoolTrimFlags
-> VkCommandPoolTrimFlags
-> [VkCommandPoolTrimFlags]
enumFromTo :: VkCommandPoolTrimFlags
-> VkCommandPoolTrimFlags -> [VkCommandPoolTrimFlags]
$cenumFromTo :: VkCommandPoolTrimFlags
-> VkCommandPoolTrimFlags -> [VkCommandPoolTrimFlags]
enumFromThen :: VkCommandPoolTrimFlags
-> VkCommandPoolTrimFlags -> [VkCommandPoolTrimFlags]
$cenumFromThen :: VkCommandPoolTrimFlags
-> VkCommandPoolTrimFlags -> [VkCommandPoolTrimFlags]
enumFrom :: VkCommandPoolTrimFlags -> [VkCommandPoolTrimFlags]
$cenumFrom :: VkCommandPoolTrimFlags -> [VkCommandPoolTrimFlags]
fromEnum :: VkCommandPoolTrimFlags -> Int
$cfromEnum :: VkCommandPoolTrimFlags -> Int
toEnum :: Int -> VkCommandPoolTrimFlags
$ctoEnum :: Int -> VkCommandPoolTrimFlags
pred :: VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags
$cpred :: VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags
succ :: VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags
$csucc :: VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags
Enum, Eq VkCommandPoolTrimFlags
VkCommandPoolTrimFlags
Eq VkCommandPoolTrimFlags
-> (VkCommandPoolTrimFlags
    -> VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags)
-> (VkCommandPoolTrimFlags
    -> VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags)
-> (VkCommandPoolTrimFlags
    -> VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags)
-> (VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags)
-> (VkCommandPoolTrimFlags -> Int -> VkCommandPoolTrimFlags)
-> (VkCommandPoolTrimFlags -> Int -> VkCommandPoolTrimFlags)
-> VkCommandPoolTrimFlags
-> (Int -> VkCommandPoolTrimFlags)
-> (VkCommandPoolTrimFlags -> Int -> VkCommandPoolTrimFlags)
-> (VkCommandPoolTrimFlags -> Int -> VkCommandPoolTrimFlags)
-> (VkCommandPoolTrimFlags -> Int -> VkCommandPoolTrimFlags)
-> (VkCommandPoolTrimFlags -> Int -> Bool)
-> (VkCommandPoolTrimFlags -> Maybe Int)
-> (VkCommandPoolTrimFlags -> Int)
-> (VkCommandPoolTrimFlags -> Bool)
-> (VkCommandPoolTrimFlags -> Int -> VkCommandPoolTrimFlags)
-> (VkCommandPoolTrimFlags -> Int -> VkCommandPoolTrimFlags)
-> (VkCommandPoolTrimFlags -> Int -> VkCommandPoolTrimFlags)
-> (VkCommandPoolTrimFlags -> Int -> VkCommandPoolTrimFlags)
-> (VkCommandPoolTrimFlags -> Int -> VkCommandPoolTrimFlags)
-> (VkCommandPoolTrimFlags -> Int -> VkCommandPoolTrimFlags)
-> (VkCommandPoolTrimFlags -> Int)
-> Bits VkCommandPoolTrimFlags
Int -> VkCommandPoolTrimFlags
VkCommandPoolTrimFlags -> Bool
VkCommandPoolTrimFlags -> Int
VkCommandPoolTrimFlags -> Maybe Int
VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags
VkCommandPoolTrimFlags -> Int -> Bool
VkCommandPoolTrimFlags -> Int -> VkCommandPoolTrimFlags
VkCommandPoolTrimFlags
-> VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags
forall a.
Eq a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
popCount :: VkCommandPoolTrimFlags -> Int
$cpopCount :: VkCommandPoolTrimFlags -> Int
rotateR :: VkCommandPoolTrimFlags -> Int -> VkCommandPoolTrimFlags
$crotateR :: VkCommandPoolTrimFlags -> Int -> VkCommandPoolTrimFlags
rotateL :: VkCommandPoolTrimFlags -> Int -> VkCommandPoolTrimFlags
$crotateL :: VkCommandPoolTrimFlags -> Int -> VkCommandPoolTrimFlags
unsafeShiftR :: VkCommandPoolTrimFlags -> Int -> VkCommandPoolTrimFlags
$cunsafeShiftR :: VkCommandPoolTrimFlags -> Int -> VkCommandPoolTrimFlags
shiftR :: VkCommandPoolTrimFlags -> Int -> VkCommandPoolTrimFlags
$cshiftR :: VkCommandPoolTrimFlags -> Int -> VkCommandPoolTrimFlags
unsafeShiftL :: VkCommandPoolTrimFlags -> Int -> VkCommandPoolTrimFlags
$cunsafeShiftL :: VkCommandPoolTrimFlags -> Int -> VkCommandPoolTrimFlags
shiftL :: VkCommandPoolTrimFlags -> Int -> VkCommandPoolTrimFlags
$cshiftL :: VkCommandPoolTrimFlags -> Int -> VkCommandPoolTrimFlags
isSigned :: VkCommandPoolTrimFlags -> Bool
$cisSigned :: VkCommandPoolTrimFlags -> Bool
bitSize :: VkCommandPoolTrimFlags -> Int
$cbitSize :: VkCommandPoolTrimFlags -> Int
bitSizeMaybe :: VkCommandPoolTrimFlags -> Maybe Int
$cbitSizeMaybe :: VkCommandPoolTrimFlags -> Maybe Int
testBit :: VkCommandPoolTrimFlags -> Int -> Bool
$ctestBit :: VkCommandPoolTrimFlags -> Int -> Bool
complementBit :: VkCommandPoolTrimFlags -> Int -> VkCommandPoolTrimFlags
$ccomplementBit :: VkCommandPoolTrimFlags -> Int -> VkCommandPoolTrimFlags
clearBit :: VkCommandPoolTrimFlags -> Int -> VkCommandPoolTrimFlags
$cclearBit :: VkCommandPoolTrimFlags -> Int -> VkCommandPoolTrimFlags
setBit :: VkCommandPoolTrimFlags -> Int -> VkCommandPoolTrimFlags
$csetBit :: VkCommandPoolTrimFlags -> Int -> VkCommandPoolTrimFlags
bit :: Int -> VkCommandPoolTrimFlags
$cbit :: Int -> VkCommandPoolTrimFlags
zeroBits :: VkCommandPoolTrimFlags
$czeroBits :: VkCommandPoolTrimFlags
rotate :: VkCommandPoolTrimFlags -> Int -> VkCommandPoolTrimFlags
$crotate :: VkCommandPoolTrimFlags -> Int -> VkCommandPoolTrimFlags
shift :: VkCommandPoolTrimFlags -> Int -> VkCommandPoolTrimFlags
$cshift :: VkCommandPoolTrimFlags -> Int -> VkCommandPoolTrimFlags
complement :: VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags
$ccomplement :: VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags
xor :: VkCommandPoolTrimFlags
-> VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags
$cxor :: VkCommandPoolTrimFlags
-> VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags
.|. :: VkCommandPoolTrimFlags
-> VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags
$c.|. :: VkCommandPoolTrimFlags
-> VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags
.&. :: VkCommandPoolTrimFlags
-> VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags
$c.&. :: VkCommandPoolTrimFlags
-> VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags
Bits, Bits VkCommandPoolTrimFlags
Bits VkCommandPoolTrimFlags
-> (VkCommandPoolTrimFlags -> Int)
-> (VkCommandPoolTrimFlags -> Int)
-> (VkCommandPoolTrimFlags -> Int)
-> FiniteBits VkCommandPoolTrimFlags
VkCommandPoolTrimFlags -> Int
forall b.
Bits b -> (b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
countTrailingZeros :: VkCommandPoolTrimFlags -> Int
$ccountTrailingZeros :: VkCommandPoolTrimFlags -> Int
countLeadingZeros :: VkCommandPoolTrimFlags -> Int
$ccountLeadingZeros :: VkCommandPoolTrimFlags -> Int
finiteBitSize :: VkCommandPoolTrimFlags -> Int
$cfiniteBitSize :: VkCommandPoolTrimFlags -> Int
FiniteBits, Ptr VkCommandPoolTrimFlags -> IO VkCommandPoolTrimFlags
Ptr VkCommandPoolTrimFlags -> Int -> IO VkCommandPoolTrimFlags
Ptr VkCommandPoolTrimFlags
-> Int -> VkCommandPoolTrimFlags -> IO ()
Ptr VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags -> IO ()
VkCommandPoolTrimFlags -> Int
(VkCommandPoolTrimFlags -> Int)
-> (VkCommandPoolTrimFlags -> Int)
-> (Ptr VkCommandPoolTrimFlags -> Int -> IO VkCommandPoolTrimFlags)
-> (Ptr VkCommandPoolTrimFlags
    -> Int -> VkCommandPoolTrimFlags -> IO ())
-> (forall b. Ptr b -> Int -> IO VkCommandPoolTrimFlags)
-> (forall b. Ptr b -> Int -> VkCommandPoolTrimFlags -> IO ())
-> (Ptr VkCommandPoolTrimFlags -> IO VkCommandPoolTrimFlags)
-> (Ptr VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags -> IO ())
-> Storable VkCommandPoolTrimFlags
forall b. Ptr b -> Int -> IO VkCommandPoolTrimFlags
forall b. Ptr b -> Int -> VkCommandPoolTrimFlags -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags -> IO ()
$cpoke :: Ptr VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags -> IO ()
peek :: Ptr VkCommandPoolTrimFlags -> IO VkCommandPoolTrimFlags
$cpeek :: Ptr VkCommandPoolTrimFlags -> IO VkCommandPoolTrimFlags
pokeByteOff :: forall b. Ptr b -> Int -> VkCommandPoolTrimFlags -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> VkCommandPoolTrimFlags -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO VkCommandPoolTrimFlags
$cpeekByteOff :: forall b. Ptr b -> Int -> IO VkCommandPoolTrimFlags
pokeElemOff :: Ptr VkCommandPoolTrimFlags
-> Int -> VkCommandPoolTrimFlags -> IO ()
$cpokeElemOff :: Ptr VkCommandPoolTrimFlags
-> Int -> VkCommandPoolTrimFlags -> IO ()
peekElemOff :: Ptr VkCommandPoolTrimFlags -> Int -> IO VkCommandPoolTrimFlags
$cpeekElemOff :: Ptr VkCommandPoolTrimFlags -> Int -> IO VkCommandPoolTrimFlags
alignment :: VkCommandPoolTrimFlags -> Int
$calignment :: VkCommandPoolTrimFlags -> Int
sizeOf :: VkCommandPoolTrimFlags -> Int
$csizeOf :: VkCommandPoolTrimFlags -> Int
Storable)

instance Show VkCommandPoolTrimFlags where
    {-# INLINE showsPrec #-}
    showsPrec :: Int -> VkCommandPoolTrimFlags -> ShowS
showsPrec = (Int -> VkFlags -> ShowS) -> Int -> VkCommandPoolTrimFlags -> ShowS
coerce (Int -> VkFlags -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec :: Int -> VkFlags -> ShowS)

instance Read VkCommandPoolTrimFlags where
    {-# INLINE readsPrec #-}
    readsPrec :: Int -> ReadS VkCommandPoolTrimFlags
readsPrec = (Int -> ReadS VkFlags) -> Int -> ReadS VkCommandPoolTrimFlags
coerce (Int -> ReadS VkFlags
forall a. Read a => Int -> ReadS a
readsPrec :: Int -> ReadS VkFlags)

newtype VkCommandPoolTrimFlagsKHR = VkCommandPoolTrimFlagsKHR VkFlags
                                    deriving (VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR -> Bool
(VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR -> Bool)
-> (VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR -> Bool)
-> Eq VkCommandPoolTrimFlagsKHR
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR -> Bool
$c/= :: VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR -> Bool
== :: VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR -> Bool
$c== :: VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR -> Bool
Eq, Eq VkCommandPoolTrimFlagsKHR
Eq VkCommandPoolTrimFlagsKHR
-> (VkCommandPoolTrimFlagsKHR
    -> VkCommandPoolTrimFlagsKHR -> Ordering)
-> (VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR -> Bool)
-> (VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR -> Bool)
-> (VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR -> Bool)
-> (VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR -> Bool)
-> (VkCommandPoolTrimFlagsKHR
    -> VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR)
-> (VkCommandPoolTrimFlagsKHR
    -> VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR)
-> Ord VkCommandPoolTrimFlagsKHR
VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR -> Bool
VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR -> Ordering
VkCommandPoolTrimFlagsKHR
-> VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: VkCommandPoolTrimFlagsKHR
-> VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR
$cmin :: VkCommandPoolTrimFlagsKHR
-> VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR
max :: VkCommandPoolTrimFlagsKHR
-> VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR
$cmax :: VkCommandPoolTrimFlagsKHR
-> VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR
>= :: VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR -> Bool
$c>= :: VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR -> Bool
> :: VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR -> Bool
$c> :: VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR -> Bool
<= :: VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR -> Bool
$c<= :: VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR -> Bool
< :: VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR -> Bool
$c< :: VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR -> Bool
compare :: VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR -> Ordering
$ccompare :: VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR -> Ordering
Ord, Int -> VkCommandPoolTrimFlagsKHR
VkCommandPoolTrimFlagsKHR -> Int
VkCommandPoolTrimFlagsKHR -> [VkCommandPoolTrimFlagsKHR]
VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR
VkCommandPoolTrimFlagsKHR
-> VkCommandPoolTrimFlagsKHR -> [VkCommandPoolTrimFlagsKHR]
VkCommandPoolTrimFlagsKHR
-> VkCommandPoolTrimFlagsKHR
-> VkCommandPoolTrimFlagsKHR
-> [VkCommandPoolTrimFlagsKHR]
(VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR)
-> (VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR)
-> (Int -> VkCommandPoolTrimFlagsKHR)
-> (VkCommandPoolTrimFlagsKHR -> Int)
-> (VkCommandPoolTrimFlagsKHR -> [VkCommandPoolTrimFlagsKHR])
-> (VkCommandPoolTrimFlagsKHR
    -> VkCommandPoolTrimFlagsKHR -> [VkCommandPoolTrimFlagsKHR])
-> (VkCommandPoolTrimFlagsKHR
    -> VkCommandPoolTrimFlagsKHR -> [VkCommandPoolTrimFlagsKHR])
-> (VkCommandPoolTrimFlagsKHR
    -> VkCommandPoolTrimFlagsKHR
    -> VkCommandPoolTrimFlagsKHR
    -> [VkCommandPoolTrimFlagsKHR])
-> Enum VkCommandPoolTrimFlagsKHR
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: VkCommandPoolTrimFlagsKHR
-> VkCommandPoolTrimFlagsKHR
-> VkCommandPoolTrimFlagsKHR
-> [VkCommandPoolTrimFlagsKHR]
$cenumFromThenTo :: VkCommandPoolTrimFlagsKHR
-> VkCommandPoolTrimFlagsKHR
-> VkCommandPoolTrimFlagsKHR
-> [VkCommandPoolTrimFlagsKHR]
enumFromTo :: VkCommandPoolTrimFlagsKHR
-> VkCommandPoolTrimFlagsKHR -> [VkCommandPoolTrimFlagsKHR]
$cenumFromTo :: VkCommandPoolTrimFlagsKHR
-> VkCommandPoolTrimFlagsKHR -> [VkCommandPoolTrimFlagsKHR]
enumFromThen :: VkCommandPoolTrimFlagsKHR
-> VkCommandPoolTrimFlagsKHR -> [VkCommandPoolTrimFlagsKHR]
$cenumFromThen :: VkCommandPoolTrimFlagsKHR
-> VkCommandPoolTrimFlagsKHR -> [VkCommandPoolTrimFlagsKHR]
enumFrom :: VkCommandPoolTrimFlagsKHR -> [VkCommandPoolTrimFlagsKHR]
$cenumFrom :: VkCommandPoolTrimFlagsKHR -> [VkCommandPoolTrimFlagsKHR]
fromEnum :: VkCommandPoolTrimFlagsKHR -> Int
$cfromEnum :: VkCommandPoolTrimFlagsKHR -> Int
toEnum :: Int -> VkCommandPoolTrimFlagsKHR
$ctoEnum :: Int -> VkCommandPoolTrimFlagsKHR
pred :: VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR
$cpred :: VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR
succ :: VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR
$csucc :: VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR
Enum, Eq VkCommandPoolTrimFlagsKHR
VkCommandPoolTrimFlagsKHR
Eq VkCommandPoolTrimFlagsKHR
-> (VkCommandPoolTrimFlagsKHR
    -> VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR)
-> (VkCommandPoolTrimFlagsKHR
    -> VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR)
-> (VkCommandPoolTrimFlagsKHR
    -> VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR)
-> (VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR)
-> (VkCommandPoolTrimFlagsKHR -> Int -> VkCommandPoolTrimFlagsKHR)
-> (VkCommandPoolTrimFlagsKHR -> Int -> VkCommandPoolTrimFlagsKHR)
-> VkCommandPoolTrimFlagsKHR
-> (Int -> VkCommandPoolTrimFlagsKHR)
-> (VkCommandPoolTrimFlagsKHR -> Int -> VkCommandPoolTrimFlagsKHR)
-> (VkCommandPoolTrimFlagsKHR -> Int -> VkCommandPoolTrimFlagsKHR)
-> (VkCommandPoolTrimFlagsKHR -> Int -> VkCommandPoolTrimFlagsKHR)
-> (VkCommandPoolTrimFlagsKHR -> Int -> Bool)
-> (VkCommandPoolTrimFlagsKHR -> Maybe Int)
-> (VkCommandPoolTrimFlagsKHR -> Int)
-> (VkCommandPoolTrimFlagsKHR -> Bool)
-> (VkCommandPoolTrimFlagsKHR -> Int -> VkCommandPoolTrimFlagsKHR)
-> (VkCommandPoolTrimFlagsKHR -> Int -> VkCommandPoolTrimFlagsKHR)
-> (VkCommandPoolTrimFlagsKHR -> Int -> VkCommandPoolTrimFlagsKHR)
-> (VkCommandPoolTrimFlagsKHR -> Int -> VkCommandPoolTrimFlagsKHR)
-> (VkCommandPoolTrimFlagsKHR -> Int -> VkCommandPoolTrimFlagsKHR)
-> (VkCommandPoolTrimFlagsKHR -> Int -> VkCommandPoolTrimFlagsKHR)
-> (VkCommandPoolTrimFlagsKHR -> Int)
-> Bits VkCommandPoolTrimFlagsKHR
Int -> VkCommandPoolTrimFlagsKHR
VkCommandPoolTrimFlagsKHR -> Bool
VkCommandPoolTrimFlagsKHR -> Int
VkCommandPoolTrimFlagsKHR -> Maybe Int
VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR
VkCommandPoolTrimFlagsKHR -> Int -> Bool
VkCommandPoolTrimFlagsKHR -> Int -> VkCommandPoolTrimFlagsKHR
VkCommandPoolTrimFlagsKHR
-> VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR
forall a.
Eq a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
popCount :: VkCommandPoolTrimFlagsKHR -> Int
$cpopCount :: VkCommandPoolTrimFlagsKHR -> Int
rotateR :: VkCommandPoolTrimFlagsKHR -> Int -> VkCommandPoolTrimFlagsKHR
$crotateR :: VkCommandPoolTrimFlagsKHR -> Int -> VkCommandPoolTrimFlagsKHR
rotateL :: VkCommandPoolTrimFlagsKHR -> Int -> VkCommandPoolTrimFlagsKHR
$crotateL :: VkCommandPoolTrimFlagsKHR -> Int -> VkCommandPoolTrimFlagsKHR
unsafeShiftR :: VkCommandPoolTrimFlagsKHR -> Int -> VkCommandPoolTrimFlagsKHR
$cunsafeShiftR :: VkCommandPoolTrimFlagsKHR -> Int -> VkCommandPoolTrimFlagsKHR
shiftR :: VkCommandPoolTrimFlagsKHR -> Int -> VkCommandPoolTrimFlagsKHR
$cshiftR :: VkCommandPoolTrimFlagsKHR -> Int -> VkCommandPoolTrimFlagsKHR
unsafeShiftL :: VkCommandPoolTrimFlagsKHR -> Int -> VkCommandPoolTrimFlagsKHR
$cunsafeShiftL :: VkCommandPoolTrimFlagsKHR -> Int -> VkCommandPoolTrimFlagsKHR
shiftL :: VkCommandPoolTrimFlagsKHR -> Int -> VkCommandPoolTrimFlagsKHR
$cshiftL :: VkCommandPoolTrimFlagsKHR -> Int -> VkCommandPoolTrimFlagsKHR
isSigned :: VkCommandPoolTrimFlagsKHR -> Bool
$cisSigned :: VkCommandPoolTrimFlagsKHR -> Bool
bitSize :: VkCommandPoolTrimFlagsKHR -> Int
$cbitSize :: VkCommandPoolTrimFlagsKHR -> Int
bitSizeMaybe :: VkCommandPoolTrimFlagsKHR -> Maybe Int
$cbitSizeMaybe :: VkCommandPoolTrimFlagsKHR -> Maybe Int
testBit :: VkCommandPoolTrimFlagsKHR -> Int -> Bool
$ctestBit :: VkCommandPoolTrimFlagsKHR -> Int -> Bool
complementBit :: VkCommandPoolTrimFlagsKHR -> Int -> VkCommandPoolTrimFlagsKHR
$ccomplementBit :: VkCommandPoolTrimFlagsKHR -> Int -> VkCommandPoolTrimFlagsKHR
clearBit :: VkCommandPoolTrimFlagsKHR -> Int -> VkCommandPoolTrimFlagsKHR
$cclearBit :: VkCommandPoolTrimFlagsKHR -> Int -> VkCommandPoolTrimFlagsKHR
setBit :: VkCommandPoolTrimFlagsKHR -> Int -> VkCommandPoolTrimFlagsKHR
$csetBit :: VkCommandPoolTrimFlagsKHR -> Int -> VkCommandPoolTrimFlagsKHR
bit :: Int -> VkCommandPoolTrimFlagsKHR
$cbit :: Int -> VkCommandPoolTrimFlagsKHR
zeroBits :: VkCommandPoolTrimFlagsKHR
$czeroBits :: VkCommandPoolTrimFlagsKHR
rotate :: VkCommandPoolTrimFlagsKHR -> Int -> VkCommandPoolTrimFlagsKHR
$crotate :: VkCommandPoolTrimFlagsKHR -> Int -> VkCommandPoolTrimFlagsKHR
shift :: VkCommandPoolTrimFlagsKHR -> Int -> VkCommandPoolTrimFlagsKHR
$cshift :: VkCommandPoolTrimFlagsKHR -> Int -> VkCommandPoolTrimFlagsKHR
complement :: VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR
$ccomplement :: VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR
xor :: VkCommandPoolTrimFlagsKHR
-> VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR
$cxor :: VkCommandPoolTrimFlagsKHR
-> VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR
.|. :: VkCommandPoolTrimFlagsKHR
-> VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR
$c.|. :: VkCommandPoolTrimFlagsKHR
-> VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR
.&. :: VkCommandPoolTrimFlagsKHR
-> VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR
$c.&. :: VkCommandPoolTrimFlagsKHR
-> VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR
Bits, Bits VkCommandPoolTrimFlagsKHR
Bits VkCommandPoolTrimFlagsKHR
-> (VkCommandPoolTrimFlagsKHR -> Int)
-> (VkCommandPoolTrimFlagsKHR -> Int)
-> (VkCommandPoolTrimFlagsKHR -> Int)
-> FiniteBits VkCommandPoolTrimFlagsKHR
VkCommandPoolTrimFlagsKHR -> Int
forall b.
Bits b -> (b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
countTrailingZeros :: VkCommandPoolTrimFlagsKHR -> Int
$ccountTrailingZeros :: VkCommandPoolTrimFlagsKHR -> Int
countLeadingZeros :: VkCommandPoolTrimFlagsKHR -> Int
$ccountLeadingZeros :: VkCommandPoolTrimFlagsKHR -> Int
finiteBitSize :: VkCommandPoolTrimFlagsKHR -> Int
$cfiniteBitSize :: VkCommandPoolTrimFlagsKHR -> Int
FiniteBits, Ptr VkCommandPoolTrimFlagsKHR -> IO VkCommandPoolTrimFlagsKHR
Ptr VkCommandPoolTrimFlagsKHR
-> Int -> IO VkCommandPoolTrimFlagsKHR
Ptr VkCommandPoolTrimFlagsKHR
-> Int -> VkCommandPoolTrimFlagsKHR -> IO ()
Ptr VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR -> IO ()
VkCommandPoolTrimFlagsKHR -> Int
(VkCommandPoolTrimFlagsKHR -> Int)
-> (VkCommandPoolTrimFlagsKHR -> Int)
-> (Ptr VkCommandPoolTrimFlagsKHR
    -> Int -> IO VkCommandPoolTrimFlagsKHR)
-> (Ptr VkCommandPoolTrimFlagsKHR
    -> Int -> VkCommandPoolTrimFlagsKHR -> IO ())
-> (forall b. Ptr b -> Int -> IO VkCommandPoolTrimFlagsKHR)
-> (forall b. Ptr b -> Int -> VkCommandPoolTrimFlagsKHR -> IO ())
-> (Ptr VkCommandPoolTrimFlagsKHR -> IO VkCommandPoolTrimFlagsKHR)
-> (Ptr VkCommandPoolTrimFlagsKHR
    -> VkCommandPoolTrimFlagsKHR -> IO ())
-> Storable VkCommandPoolTrimFlagsKHR
forall b. Ptr b -> Int -> IO VkCommandPoolTrimFlagsKHR
forall b. Ptr b -> Int -> VkCommandPoolTrimFlagsKHR -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR -> IO ()
$cpoke :: Ptr VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR -> IO ()
peek :: Ptr VkCommandPoolTrimFlagsKHR -> IO VkCommandPoolTrimFlagsKHR
$cpeek :: Ptr VkCommandPoolTrimFlagsKHR -> IO VkCommandPoolTrimFlagsKHR
pokeByteOff :: forall b. Ptr b -> Int -> VkCommandPoolTrimFlagsKHR -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> VkCommandPoolTrimFlagsKHR -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO VkCommandPoolTrimFlagsKHR
$cpeekByteOff :: forall b. Ptr b -> Int -> IO VkCommandPoolTrimFlagsKHR
pokeElemOff :: Ptr VkCommandPoolTrimFlagsKHR
-> Int -> VkCommandPoolTrimFlagsKHR -> IO ()
$cpokeElemOff :: Ptr VkCommandPoolTrimFlagsKHR
-> Int -> VkCommandPoolTrimFlagsKHR -> IO ()
peekElemOff :: Ptr VkCommandPoolTrimFlagsKHR
-> Int -> IO VkCommandPoolTrimFlagsKHR
$cpeekElemOff :: Ptr VkCommandPoolTrimFlagsKHR
-> Int -> IO VkCommandPoolTrimFlagsKHR
alignment :: VkCommandPoolTrimFlagsKHR -> Int
$calignment :: VkCommandPoolTrimFlagsKHR -> Int
sizeOf :: VkCommandPoolTrimFlagsKHR -> Int
$csizeOf :: VkCommandPoolTrimFlagsKHR -> Int
Storable)

instance Show VkCommandPoolTrimFlagsKHR where
    {-# INLINE showsPrec #-}
    showsPrec :: Int -> VkCommandPoolTrimFlagsKHR -> ShowS
showsPrec = (Int -> VkFlags -> ShowS)
-> Int -> VkCommandPoolTrimFlagsKHR -> ShowS
coerce (Int -> VkFlags -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec :: Int -> VkFlags -> ShowS)

instance Read VkCommandPoolTrimFlagsKHR where
    {-# INLINE readsPrec #-}
    readsPrec :: Int -> ReadS VkCommandPoolTrimFlagsKHR
readsPrec = (Int -> ReadS VkFlags) -> Int -> ReadS VkCommandPoolTrimFlagsKHR
coerce (Int -> ReadS VkFlags
forall a. Read a => Int -> ReadS a
readsPrec :: Int -> ReadS VkFlags)

newtype VkDebugUtilsMessengerCallbackDataFlagsEXT = VkDebugUtilsMessengerCallbackDataFlagsEXT VkFlags
                                                    deriving (VkDebugUtilsMessengerCallbackDataFlagsEXT
-> VkDebugUtilsMessengerCallbackDataFlagsEXT -> Bool
(VkDebugUtilsMessengerCallbackDataFlagsEXT
 -> VkDebugUtilsMessengerCallbackDataFlagsEXT -> Bool)
-> (VkDebugUtilsMessengerCallbackDataFlagsEXT
    -> VkDebugUtilsMessengerCallbackDataFlagsEXT -> Bool)
-> Eq VkDebugUtilsMessengerCallbackDataFlagsEXT
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VkDebugUtilsMessengerCallbackDataFlagsEXT
-> VkDebugUtilsMessengerCallbackDataFlagsEXT -> Bool
$c/= :: VkDebugUtilsMessengerCallbackDataFlagsEXT
-> VkDebugUtilsMessengerCallbackDataFlagsEXT -> Bool
== :: VkDebugUtilsMessengerCallbackDataFlagsEXT
-> VkDebugUtilsMessengerCallbackDataFlagsEXT -> Bool
$c== :: VkDebugUtilsMessengerCallbackDataFlagsEXT
-> VkDebugUtilsMessengerCallbackDataFlagsEXT -> Bool
Eq, Eq VkDebugUtilsMessengerCallbackDataFlagsEXT
Eq VkDebugUtilsMessengerCallbackDataFlagsEXT
-> (VkDebugUtilsMessengerCallbackDataFlagsEXT
    -> VkDebugUtilsMessengerCallbackDataFlagsEXT -> Ordering)
-> (VkDebugUtilsMessengerCallbackDataFlagsEXT
    -> VkDebugUtilsMessengerCallbackDataFlagsEXT -> Bool)
-> (VkDebugUtilsMessengerCallbackDataFlagsEXT
    -> VkDebugUtilsMessengerCallbackDataFlagsEXT -> Bool)
-> (VkDebugUtilsMessengerCallbackDataFlagsEXT
    -> VkDebugUtilsMessengerCallbackDataFlagsEXT -> Bool)
-> (VkDebugUtilsMessengerCallbackDataFlagsEXT
    -> VkDebugUtilsMessengerCallbackDataFlagsEXT -> Bool)
-> (VkDebugUtilsMessengerCallbackDataFlagsEXT
    -> VkDebugUtilsMessengerCallbackDataFlagsEXT
    -> VkDebugUtilsMessengerCallbackDataFlagsEXT)
-> (VkDebugUtilsMessengerCallbackDataFlagsEXT
    -> VkDebugUtilsMessengerCallbackDataFlagsEXT
    -> VkDebugUtilsMessengerCallbackDataFlagsEXT)
-> Ord VkDebugUtilsMessengerCallbackDataFlagsEXT
VkDebugUtilsMessengerCallbackDataFlagsEXT
-> VkDebugUtilsMessengerCallbackDataFlagsEXT -> Bool
VkDebugUtilsMessengerCallbackDataFlagsEXT
-> VkDebugUtilsMessengerCallbackDataFlagsEXT -> Ordering
VkDebugUtilsMessengerCallbackDataFlagsEXT
-> VkDebugUtilsMessengerCallbackDataFlagsEXT
-> VkDebugUtilsMessengerCallbackDataFlagsEXT
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: VkDebugUtilsMessengerCallbackDataFlagsEXT
-> VkDebugUtilsMessengerCallbackDataFlagsEXT
-> VkDebugUtilsMessengerCallbackDataFlagsEXT
$cmin :: VkDebugUtilsMessengerCallbackDataFlagsEXT
-> VkDebugUtilsMessengerCallbackDataFlagsEXT
-> VkDebugUtilsMessengerCallbackDataFlagsEXT
max :: VkDebugUtilsMessengerCallbackDataFlagsEXT
-> VkDebugUtilsMessengerCallbackDataFlagsEXT
-> VkDebugUtilsMessengerCallbackDataFlagsEXT
$cmax :: VkDebugUtilsMessengerCallbackDataFlagsEXT
-> VkDebugUtilsMessengerCallbackDataFlagsEXT
-> VkDebugUtilsMessengerCallbackDataFlagsEXT
>= :: VkDebugUtilsMessengerCallbackDataFlagsEXT
-> VkDebugUtilsMessengerCallbackDataFlagsEXT -> Bool
$c>= :: VkDebugUtilsMessengerCallbackDataFlagsEXT
-> VkDebugUtilsMessengerCallbackDataFlagsEXT -> Bool
> :: VkDebugUtilsMessengerCallbackDataFlagsEXT
-> VkDebugUtilsMessengerCallbackDataFlagsEXT -> Bool
$c> :: VkDebugUtilsMessengerCallbackDataFlagsEXT
-> VkDebugUtilsMessengerCallbackDataFlagsEXT -> Bool
<= :: VkDebugUtilsMessengerCallbackDataFlagsEXT
-> VkDebugUtilsMessengerCallbackDataFlagsEXT -> Bool
$c<= :: VkDebugUtilsMessengerCallbackDataFlagsEXT
-> VkDebugUtilsMessengerCallbackDataFlagsEXT -> Bool
< :: VkDebugUtilsMessengerCallbackDataFlagsEXT
-> VkDebugUtilsMessengerCallbackDataFlagsEXT -> Bool
$c< :: VkDebugUtilsMessengerCallbackDataFlagsEXT
-> VkDebugUtilsMessengerCallbackDataFlagsEXT -> Bool
compare :: VkDebugUtilsMessengerCallbackDataFlagsEXT
-> VkDebugUtilsMessengerCallbackDataFlagsEXT -> Ordering
$ccompare :: VkDebugUtilsMessengerCallbackDataFlagsEXT
-> VkDebugUtilsMessengerCallbackDataFlagsEXT -> Ordering
Ord, Int -> VkDebugUtilsMessengerCallbackDataFlagsEXT
VkDebugUtilsMessengerCallbackDataFlagsEXT -> Int
VkDebugUtilsMessengerCallbackDataFlagsEXT
-> [VkDebugUtilsMessengerCallbackDataFlagsEXT]
VkDebugUtilsMessengerCallbackDataFlagsEXT
-> VkDebugUtilsMessengerCallbackDataFlagsEXT
VkDebugUtilsMessengerCallbackDataFlagsEXT
-> VkDebugUtilsMessengerCallbackDataFlagsEXT
-> [VkDebugUtilsMessengerCallbackDataFlagsEXT]
VkDebugUtilsMessengerCallbackDataFlagsEXT
-> VkDebugUtilsMessengerCallbackDataFlagsEXT
-> VkDebugUtilsMessengerCallbackDataFlagsEXT
-> [VkDebugUtilsMessengerCallbackDataFlagsEXT]
(VkDebugUtilsMessengerCallbackDataFlagsEXT
 -> VkDebugUtilsMessengerCallbackDataFlagsEXT)
-> (VkDebugUtilsMessengerCallbackDataFlagsEXT
    -> VkDebugUtilsMessengerCallbackDataFlagsEXT)
-> (Int -> VkDebugUtilsMessengerCallbackDataFlagsEXT)
-> (VkDebugUtilsMessengerCallbackDataFlagsEXT -> Int)
-> (VkDebugUtilsMessengerCallbackDataFlagsEXT
    -> [VkDebugUtilsMessengerCallbackDataFlagsEXT])
-> (VkDebugUtilsMessengerCallbackDataFlagsEXT
    -> VkDebugUtilsMessengerCallbackDataFlagsEXT
    -> [VkDebugUtilsMessengerCallbackDataFlagsEXT])
-> (VkDebugUtilsMessengerCallbackDataFlagsEXT
    -> VkDebugUtilsMessengerCallbackDataFlagsEXT
    -> [VkDebugUtilsMessengerCallbackDataFlagsEXT])
-> (VkDebugUtilsMessengerCallbackDataFlagsEXT
    -> VkDebugUtilsMessengerCallbackDataFlagsEXT
    -> VkDebugUtilsMessengerCallbackDataFlagsEXT
    -> [VkDebugUtilsMessengerCallbackDataFlagsEXT])
-> Enum VkDebugUtilsMessengerCallbackDataFlagsEXT
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: VkDebugUtilsMessengerCallbackDataFlagsEXT
-> VkDebugUtilsMessengerCallbackDataFlagsEXT
-> VkDebugUtilsMessengerCallbackDataFlagsEXT
-> [VkDebugUtilsMessengerCallbackDataFlagsEXT]
$cenumFromThenTo :: VkDebugUtilsMessengerCallbackDataFlagsEXT
-> VkDebugUtilsMessengerCallbackDataFlagsEXT
-> VkDebugUtilsMessengerCallbackDataFlagsEXT
-> [VkDebugUtilsMessengerCallbackDataFlagsEXT]
enumFromTo :: VkDebugUtilsMessengerCallbackDataFlagsEXT
-> VkDebugUtilsMessengerCallbackDataFlagsEXT
-> [VkDebugUtilsMessengerCallbackDataFlagsEXT]
$cenumFromTo :: VkDebugUtilsMessengerCallbackDataFlagsEXT
-> VkDebugUtilsMessengerCallbackDataFlagsEXT
-> [VkDebugUtilsMessengerCallbackDataFlagsEXT]
enumFromThen :: VkDebugUtilsMessengerCallbackDataFlagsEXT
-> VkDebugUtilsMessengerCallbackDataFlagsEXT
-> [VkDebugUtilsMessengerCallbackDataFlagsEXT]
$cenumFromThen :: VkDebugUtilsMessengerCallbackDataFlagsEXT
-> VkDebugUtilsMessengerCallbackDataFlagsEXT
-> [VkDebugUtilsMessengerCallbackDataFlagsEXT]
enumFrom :: VkDebugUtilsMessengerCallbackDataFlagsEXT
-> [VkDebugUtilsMessengerCallbackDataFlagsEXT]
$cenumFrom :: VkDebugUtilsMessengerCallbackDataFlagsEXT
-> [VkDebugUtilsMessengerCallbackDataFlagsEXT]
fromEnum :: VkDebugUtilsMessengerCallbackDataFlagsEXT -> Int
$cfromEnum :: VkDebugUtilsMessengerCallbackDataFlagsEXT -> Int
toEnum :: Int -> VkDebugUtilsMessengerCallbackDataFlagsEXT
$ctoEnum :: Int -> VkDebugUtilsMessengerCallbackDataFlagsEXT
pred :: VkDebugUtilsMessengerCallbackDataFlagsEXT
-> VkDebugUtilsMessengerCallbackDataFlagsEXT
$cpred :: VkDebugUtilsMessengerCallbackDataFlagsEXT
-> VkDebugUtilsMessengerCallbackDataFlagsEXT
succ :: VkDebugUtilsMessengerCallbackDataFlagsEXT
-> VkDebugUtilsMessengerCallbackDataFlagsEXT
$csucc :: VkDebugUtilsMessengerCallbackDataFlagsEXT
-> VkDebugUtilsMessengerCallbackDataFlagsEXT
Enum, Eq VkDebugUtilsMessengerCallbackDataFlagsEXT
VkDebugUtilsMessengerCallbackDataFlagsEXT
Eq VkDebugUtilsMessengerCallbackDataFlagsEXT
-> (VkDebugUtilsMessengerCallbackDataFlagsEXT
    -> VkDebugUtilsMessengerCallbackDataFlagsEXT
    -> VkDebugUtilsMessengerCallbackDataFlagsEXT)
-> (VkDebugUtilsMessengerCallbackDataFlagsEXT
    -> VkDebugUtilsMessengerCallbackDataFlagsEXT
    -> VkDebugUtilsMessengerCallbackDataFlagsEXT)
-> (VkDebugUtilsMessengerCallbackDataFlagsEXT
    -> VkDebugUtilsMessengerCallbackDataFlagsEXT
    -> VkDebugUtilsMessengerCallbackDataFlagsEXT)
-> (VkDebugUtilsMessengerCallbackDataFlagsEXT
    -> VkDebugUtilsMessengerCallbackDataFlagsEXT)
-> (VkDebugUtilsMessengerCallbackDataFlagsEXT
    -> Int -> VkDebugUtilsMessengerCallbackDataFlagsEXT)
-> (VkDebugUtilsMessengerCallbackDataFlagsEXT
    -> Int -> VkDebugUtilsMessengerCallbackDataFlagsEXT)
-> VkDebugUtilsMessengerCallbackDataFlagsEXT
-> (Int -> VkDebugUtilsMessengerCallbackDataFlagsEXT)
-> (VkDebugUtilsMessengerCallbackDataFlagsEXT
    -> Int -> VkDebugUtilsMessengerCallbackDataFlagsEXT)
-> (VkDebugUtilsMessengerCallbackDataFlagsEXT
    -> Int -> VkDebugUtilsMessengerCallbackDataFlagsEXT)
-> (VkDebugUtilsMessengerCallbackDataFlagsEXT
    -> Int -> VkDebugUtilsMessengerCallbackDataFlagsEXT)
-> (VkDebugUtilsMessengerCallbackDataFlagsEXT -> Int -> Bool)
-> (VkDebugUtilsMessengerCallbackDataFlagsEXT -> Maybe Int)
-> (VkDebugUtilsMessengerCallbackDataFlagsEXT -> Int)
-> (VkDebugUtilsMessengerCallbackDataFlagsEXT -> Bool)
-> (VkDebugUtilsMessengerCallbackDataFlagsEXT
    -> Int -> VkDebugUtilsMessengerCallbackDataFlagsEXT)
-> (VkDebugUtilsMessengerCallbackDataFlagsEXT
    -> Int -> VkDebugUtilsMessengerCallbackDataFlagsEXT)
-> (VkDebugUtilsMessengerCallbackDataFlagsEXT
    -> Int -> VkDebugUtilsMessengerCallbackDataFlagsEXT)
-> (VkDebugUtilsMessengerCallbackDataFlagsEXT
    -> Int -> VkDebugUtilsMessengerCallbackDataFlagsEXT)
-> (VkDebugUtilsMessengerCallbackDataFlagsEXT
    -> Int -> VkDebugUtilsMessengerCallbackDataFlagsEXT)
-> (VkDebugUtilsMessengerCallbackDataFlagsEXT
    -> Int -> VkDebugUtilsMessengerCallbackDataFlagsEXT)
-> (VkDebugUtilsMessengerCallbackDataFlagsEXT -> Int)
-> Bits VkDebugUtilsMessengerCallbackDataFlagsEXT
Int -> VkDebugUtilsMessengerCallbackDataFlagsEXT
VkDebugUtilsMessengerCallbackDataFlagsEXT -> Bool
VkDebugUtilsMessengerCallbackDataFlagsEXT -> Int
VkDebugUtilsMessengerCallbackDataFlagsEXT -> Maybe Int
VkDebugUtilsMessengerCallbackDataFlagsEXT
-> VkDebugUtilsMessengerCallbackDataFlagsEXT
VkDebugUtilsMessengerCallbackDataFlagsEXT -> Int -> Bool
VkDebugUtilsMessengerCallbackDataFlagsEXT
-> Int -> VkDebugUtilsMessengerCallbackDataFlagsEXT
VkDebugUtilsMessengerCallbackDataFlagsEXT
-> VkDebugUtilsMessengerCallbackDataFlagsEXT
-> VkDebugUtilsMessengerCallbackDataFlagsEXT
forall a.
Eq a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
popCount :: VkDebugUtilsMessengerCallbackDataFlagsEXT -> Int
$cpopCount :: VkDebugUtilsMessengerCallbackDataFlagsEXT -> Int
rotateR :: VkDebugUtilsMessengerCallbackDataFlagsEXT
-> Int -> VkDebugUtilsMessengerCallbackDataFlagsEXT
$crotateR :: VkDebugUtilsMessengerCallbackDataFlagsEXT
-> Int -> VkDebugUtilsMessengerCallbackDataFlagsEXT
rotateL :: VkDebugUtilsMessengerCallbackDataFlagsEXT
-> Int -> VkDebugUtilsMessengerCallbackDataFlagsEXT
$crotateL :: VkDebugUtilsMessengerCallbackDataFlagsEXT
-> Int -> VkDebugUtilsMessengerCallbackDataFlagsEXT
unsafeShiftR :: VkDebugUtilsMessengerCallbackDataFlagsEXT
-> Int -> VkDebugUtilsMessengerCallbackDataFlagsEXT
$cunsafeShiftR :: VkDebugUtilsMessengerCallbackDataFlagsEXT
-> Int -> VkDebugUtilsMessengerCallbackDataFlagsEXT
shiftR :: VkDebugUtilsMessengerCallbackDataFlagsEXT
-> Int -> VkDebugUtilsMessengerCallbackDataFlagsEXT
$cshiftR :: VkDebugUtilsMessengerCallbackDataFlagsEXT
-> Int -> VkDebugUtilsMessengerCallbackDataFlagsEXT
unsafeShiftL :: VkDebugUtilsMessengerCallbackDataFlagsEXT
-> Int -> VkDebugUtilsMessengerCallbackDataFlagsEXT
$cunsafeShiftL :: VkDebugUtilsMessengerCallbackDataFlagsEXT
-> Int -> VkDebugUtilsMessengerCallbackDataFlagsEXT
shiftL :: VkDebugUtilsMessengerCallbackDataFlagsEXT
-> Int -> VkDebugUtilsMessengerCallbackDataFlagsEXT
$cshiftL :: VkDebugUtilsMessengerCallbackDataFlagsEXT
-> Int -> VkDebugUtilsMessengerCallbackDataFlagsEXT
isSigned :: VkDebugUtilsMessengerCallbackDataFlagsEXT -> Bool
$cisSigned :: VkDebugUtilsMessengerCallbackDataFlagsEXT -> Bool
bitSize :: VkDebugUtilsMessengerCallbackDataFlagsEXT -> Int
$cbitSize :: VkDebugUtilsMessengerCallbackDataFlagsEXT -> Int
bitSizeMaybe :: VkDebugUtilsMessengerCallbackDataFlagsEXT -> Maybe Int
$cbitSizeMaybe :: VkDebugUtilsMessengerCallbackDataFlagsEXT -> Maybe Int
testBit :: VkDebugUtilsMessengerCallbackDataFlagsEXT -> Int -> Bool
$ctestBit :: VkDebugUtilsMessengerCallbackDataFlagsEXT -> Int -> Bool
complementBit :: VkDebugUtilsMessengerCallbackDataFlagsEXT
-> Int -> VkDebugUtilsMessengerCallbackDataFlagsEXT
$ccomplementBit :: VkDebugUtilsMessengerCallbackDataFlagsEXT
-> Int -> VkDebugUtilsMessengerCallbackDataFlagsEXT
clearBit :: VkDebugUtilsMessengerCallbackDataFlagsEXT
-> Int -> VkDebugUtilsMessengerCallbackDataFlagsEXT
$cclearBit :: VkDebugUtilsMessengerCallbackDataFlagsEXT
-> Int -> VkDebugUtilsMessengerCallbackDataFlagsEXT
setBit :: VkDebugUtilsMessengerCallbackDataFlagsEXT
-> Int -> VkDebugUtilsMessengerCallbackDataFlagsEXT
$csetBit :: VkDebugUtilsMessengerCallbackDataFlagsEXT
-> Int -> VkDebugUtilsMessengerCallbackDataFlagsEXT
bit :: Int -> VkDebugUtilsMessengerCallbackDataFlagsEXT
$cbit :: Int -> VkDebugUtilsMessengerCallbackDataFlagsEXT
zeroBits :: VkDebugUtilsMessengerCallbackDataFlagsEXT
$czeroBits :: VkDebugUtilsMessengerCallbackDataFlagsEXT
rotate :: VkDebugUtilsMessengerCallbackDataFlagsEXT
-> Int -> VkDebugUtilsMessengerCallbackDataFlagsEXT
$crotate :: VkDebugUtilsMessengerCallbackDataFlagsEXT
-> Int -> VkDebugUtilsMessengerCallbackDataFlagsEXT
shift :: VkDebugUtilsMessengerCallbackDataFlagsEXT
-> Int -> VkDebugUtilsMessengerCallbackDataFlagsEXT
$cshift :: VkDebugUtilsMessengerCallbackDataFlagsEXT
-> Int -> VkDebugUtilsMessengerCallbackDataFlagsEXT
complement :: VkDebugUtilsMessengerCallbackDataFlagsEXT
-> VkDebugUtilsMessengerCallbackDataFlagsEXT
$ccomplement :: VkDebugUtilsMessengerCallbackDataFlagsEXT
-> VkDebugUtilsMessengerCallbackDataFlagsEXT
xor :: VkDebugUtilsMessengerCallbackDataFlagsEXT
-> VkDebugUtilsMessengerCallbackDataFlagsEXT
-> VkDebugUtilsMessengerCallbackDataFlagsEXT
$cxor :: VkDebugUtilsMessengerCallbackDataFlagsEXT
-> VkDebugUtilsMessengerCallbackDataFlagsEXT
-> VkDebugUtilsMessengerCallbackDataFlagsEXT
.|. :: VkDebugUtilsMessengerCallbackDataFlagsEXT
-> VkDebugUtilsMessengerCallbackDataFlagsEXT
-> VkDebugUtilsMessengerCallbackDataFlagsEXT
$c.|. :: VkDebugUtilsMessengerCallbackDataFlagsEXT
-> VkDebugUtilsMessengerCallbackDataFlagsEXT
-> VkDebugUtilsMessengerCallbackDataFlagsEXT
.&. :: VkDebugUtilsMessengerCallbackDataFlagsEXT
-> VkDebugUtilsMessengerCallbackDataFlagsEXT
-> VkDebugUtilsMessengerCallbackDataFlagsEXT
$c.&. :: VkDebugUtilsMessengerCallbackDataFlagsEXT
-> VkDebugUtilsMessengerCallbackDataFlagsEXT
-> VkDebugUtilsMessengerCallbackDataFlagsEXT
Bits, Bits VkDebugUtilsMessengerCallbackDataFlagsEXT
Bits VkDebugUtilsMessengerCallbackDataFlagsEXT
-> (VkDebugUtilsMessengerCallbackDataFlagsEXT -> Int)
-> (VkDebugUtilsMessengerCallbackDataFlagsEXT -> Int)
-> (VkDebugUtilsMessengerCallbackDataFlagsEXT -> Int)
-> FiniteBits VkDebugUtilsMessengerCallbackDataFlagsEXT
VkDebugUtilsMessengerCallbackDataFlagsEXT -> Int
forall b.
Bits b -> (b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
countTrailingZeros :: VkDebugUtilsMessengerCallbackDataFlagsEXT -> Int
$ccountTrailingZeros :: VkDebugUtilsMessengerCallbackDataFlagsEXT -> Int
countLeadingZeros :: VkDebugUtilsMessengerCallbackDataFlagsEXT -> Int
$ccountLeadingZeros :: VkDebugUtilsMessengerCallbackDataFlagsEXT -> Int
finiteBitSize :: VkDebugUtilsMessengerCallbackDataFlagsEXT -> Int
$cfiniteBitSize :: VkDebugUtilsMessengerCallbackDataFlagsEXT -> Int
FiniteBits,
                                                              Ptr VkDebugUtilsMessengerCallbackDataFlagsEXT
-> IO VkDebugUtilsMessengerCallbackDataFlagsEXT
Ptr VkDebugUtilsMessengerCallbackDataFlagsEXT
-> Int -> IO VkDebugUtilsMessengerCallbackDataFlagsEXT
Ptr VkDebugUtilsMessengerCallbackDataFlagsEXT
-> Int -> VkDebugUtilsMessengerCallbackDataFlagsEXT -> IO ()
Ptr VkDebugUtilsMessengerCallbackDataFlagsEXT
-> VkDebugUtilsMessengerCallbackDataFlagsEXT -> IO ()
VkDebugUtilsMessengerCallbackDataFlagsEXT -> Int
(VkDebugUtilsMessengerCallbackDataFlagsEXT -> Int)
-> (VkDebugUtilsMessengerCallbackDataFlagsEXT -> Int)
-> (Ptr VkDebugUtilsMessengerCallbackDataFlagsEXT
    -> Int -> IO VkDebugUtilsMessengerCallbackDataFlagsEXT)
-> (Ptr VkDebugUtilsMessengerCallbackDataFlagsEXT
    -> Int -> VkDebugUtilsMessengerCallbackDataFlagsEXT -> IO ())
-> (forall b.
    Ptr b -> Int -> IO VkDebugUtilsMessengerCallbackDataFlagsEXT)
-> (forall b.
    Ptr b -> Int -> VkDebugUtilsMessengerCallbackDataFlagsEXT -> IO ())
-> (Ptr VkDebugUtilsMessengerCallbackDataFlagsEXT
    -> IO VkDebugUtilsMessengerCallbackDataFlagsEXT)
-> (Ptr VkDebugUtilsMessengerCallbackDataFlagsEXT
    -> VkDebugUtilsMessengerCallbackDataFlagsEXT -> IO ())
-> Storable VkDebugUtilsMessengerCallbackDataFlagsEXT
forall b.
Ptr b -> Int -> IO VkDebugUtilsMessengerCallbackDataFlagsEXT
forall b.
Ptr b -> Int -> VkDebugUtilsMessengerCallbackDataFlagsEXT -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr VkDebugUtilsMessengerCallbackDataFlagsEXT
-> VkDebugUtilsMessengerCallbackDataFlagsEXT -> IO ()
$cpoke :: Ptr VkDebugUtilsMessengerCallbackDataFlagsEXT
-> VkDebugUtilsMessengerCallbackDataFlagsEXT -> IO ()
peek :: Ptr VkDebugUtilsMessengerCallbackDataFlagsEXT
-> IO VkDebugUtilsMessengerCallbackDataFlagsEXT
$cpeek :: Ptr VkDebugUtilsMessengerCallbackDataFlagsEXT
-> IO VkDebugUtilsMessengerCallbackDataFlagsEXT
pokeByteOff :: forall b.
Ptr b -> Int -> VkDebugUtilsMessengerCallbackDataFlagsEXT -> IO ()
$cpokeByteOff :: forall b.
Ptr b -> Int -> VkDebugUtilsMessengerCallbackDataFlagsEXT -> IO ()
peekByteOff :: forall b.
Ptr b -> Int -> IO VkDebugUtilsMessengerCallbackDataFlagsEXT
$cpeekByteOff :: forall b.
Ptr b -> Int -> IO VkDebugUtilsMessengerCallbackDataFlagsEXT
pokeElemOff :: Ptr VkDebugUtilsMessengerCallbackDataFlagsEXT
-> Int -> VkDebugUtilsMessengerCallbackDataFlagsEXT -> IO ()
$cpokeElemOff :: Ptr VkDebugUtilsMessengerCallbackDataFlagsEXT
-> Int -> VkDebugUtilsMessengerCallbackDataFlagsEXT -> IO ()
peekElemOff :: Ptr VkDebugUtilsMessengerCallbackDataFlagsEXT
-> Int -> IO VkDebugUtilsMessengerCallbackDataFlagsEXT
$cpeekElemOff :: Ptr VkDebugUtilsMessengerCallbackDataFlagsEXT
-> Int -> IO VkDebugUtilsMessengerCallbackDataFlagsEXT
alignment :: VkDebugUtilsMessengerCallbackDataFlagsEXT -> Int
$calignment :: VkDebugUtilsMessengerCallbackDataFlagsEXT -> Int
sizeOf :: VkDebugUtilsMessengerCallbackDataFlagsEXT -> Int
$csizeOf :: VkDebugUtilsMessengerCallbackDataFlagsEXT -> Int
Storable)

instance Show VkDebugUtilsMessengerCallbackDataFlagsEXT where
    {-# INLINE showsPrec #-}
    showsPrec :: Int -> VkDebugUtilsMessengerCallbackDataFlagsEXT -> ShowS
showsPrec = (Int -> VkFlags -> ShowS)
-> Int -> VkDebugUtilsMessengerCallbackDataFlagsEXT -> ShowS
coerce (Int -> VkFlags -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec :: Int -> VkFlags -> ShowS)

instance Read VkDebugUtilsMessengerCallbackDataFlagsEXT where
    {-# INLINE readsPrec #-}
    readsPrec :: Int -> ReadS VkDebugUtilsMessengerCallbackDataFlagsEXT
readsPrec = (Int -> ReadS VkFlags)
-> Int -> ReadS VkDebugUtilsMessengerCallbackDataFlagsEXT
coerce (Int -> ReadS VkFlags
forall a. Read a => Int -> ReadS a
readsPrec :: Int -> ReadS VkFlags)

newtype VkDebugUtilsMessengerCreateFlagsEXT = VkDebugUtilsMessengerCreateFlagsEXT VkFlags
                                              deriving (VkDebugUtilsMessengerCreateFlagsEXT
-> VkDebugUtilsMessengerCreateFlagsEXT -> Bool
(VkDebugUtilsMessengerCreateFlagsEXT
 -> VkDebugUtilsMessengerCreateFlagsEXT -> Bool)
-> (VkDebugUtilsMessengerCreateFlagsEXT
    -> VkDebugUtilsMessengerCreateFlagsEXT -> Bool)
-> Eq VkDebugUtilsMessengerCreateFlagsEXT
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VkDebugUtilsMessengerCreateFlagsEXT
-> VkDebugUtilsMessengerCreateFlagsEXT -> Bool
$c/= :: VkDebugUtilsMessengerCreateFlagsEXT
-> VkDebugUtilsMessengerCreateFlagsEXT -> Bool
== :: VkDebugUtilsMessengerCreateFlagsEXT
-> VkDebugUtilsMessengerCreateFlagsEXT -> Bool
$c== :: VkDebugUtilsMessengerCreateFlagsEXT
-> VkDebugUtilsMessengerCreateFlagsEXT -> Bool
Eq, Eq VkDebugUtilsMessengerCreateFlagsEXT
Eq VkDebugUtilsMessengerCreateFlagsEXT
-> (VkDebugUtilsMessengerCreateFlagsEXT
    -> VkDebugUtilsMessengerCreateFlagsEXT -> Ordering)
-> (VkDebugUtilsMessengerCreateFlagsEXT
    -> VkDebugUtilsMessengerCreateFlagsEXT -> Bool)
-> (VkDebugUtilsMessengerCreateFlagsEXT
    -> VkDebugUtilsMessengerCreateFlagsEXT -> Bool)
-> (VkDebugUtilsMessengerCreateFlagsEXT
    -> VkDebugUtilsMessengerCreateFlagsEXT -> Bool)
-> (VkDebugUtilsMessengerCreateFlagsEXT
    -> VkDebugUtilsMessengerCreateFlagsEXT -> Bool)
-> (VkDebugUtilsMessengerCreateFlagsEXT
    -> VkDebugUtilsMessengerCreateFlagsEXT
    -> VkDebugUtilsMessengerCreateFlagsEXT)
-> (VkDebugUtilsMessengerCreateFlagsEXT
    -> VkDebugUtilsMessengerCreateFlagsEXT
    -> VkDebugUtilsMessengerCreateFlagsEXT)
-> Ord VkDebugUtilsMessengerCreateFlagsEXT
VkDebugUtilsMessengerCreateFlagsEXT
-> VkDebugUtilsMessengerCreateFlagsEXT -> Bool
VkDebugUtilsMessengerCreateFlagsEXT
-> VkDebugUtilsMessengerCreateFlagsEXT -> Ordering
VkDebugUtilsMessengerCreateFlagsEXT
-> VkDebugUtilsMessengerCreateFlagsEXT
-> VkDebugUtilsMessengerCreateFlagsEXT
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: VkDebugUtilsMessengerCreateFlagsEXT
-> VkDebugUtilsMessengerCreateFlagsEXT
-> VkDebugUtilsMessengerCreateFlagsEXT
$cmin :: VkDebugUtilsMessengerCreateFlagsEXT
-> VkDebugUtilsMessengerCreateFlagsEXT
-> VkDebugUtilsMessengerCreateFlagsEXT
max :: VkDebugUtilsMessengerCreateFlagsEXT
-> VkDebugUtilsMessengerCreateFlagsEXT
-> VkDebugUtilsMessengerCreateFlagsEXT
$cmax :: VkDebugUtilsMessengerCreateFlagsEXT
-> VkDebugUtilsMessengerCreateFlagsEXT
-> VkDebugUtilsMessengerCreateFlagsEXT
>= :: VkDebugUtilsMessengerCreateFlagsEXT
-> VkDebugUtilsMessengerCreateFlagsEXT -> Bool
$c>= :: VkDebugUtilsMessengerCreateFlagsEXT
-> VkDebugUtilsMessengerCreateFlagsEXT -> Bool
> :: VkDebugUtilsMessengerCreateFlagsEXT
-> VkDebugUtilsMessengerCreateFlagsEXT -> Bool
$c> :: VkDebugUtilsMessengerCreateFlagsEXT
-> VkDebugUtilsMessengerCreateFlagsEXT -> Bool
<= :: VkDebugUtilsMessengerCreateFlagsEXT
-> VkDebugUtilsMessengerCreateFlagsEXT -> Bool
$c<= :: VkDebugUtilsMessengerCreateFlagsEXT
-> VkDebugUtilsMessengerCreateFlagsEXT -> Bool
< :: VkDebugUtilsMessengerCreateFlagsEXT
-> VkDebugUtilsMessengerCreateFlagsEXT -> Bool
$c< :: VkDebugUtilsMessengerCreateFlagsEXT
-> VkDebugUtilsMessengerCreateFlagsEXT -> Bool
compare :: VkDebugUtilsMessengerCreateFlagsEXT
-> VkDebugUtilsMessengerCreateFlagsEXT -> Ordering
$ccompare :: VkDebugUtilsMessengerCreateFlagsEXT
-> VkDebugUtilsMessengerCreateFlagsEXT -> Ordering
Ord, Int -> VkDebugUtilsMessengerCreateFlagsEXT
VkDebugUtilsMessengerCreateFlagsEXT -> Int
VkDebugUtilsMessengerCreateFlagsEXT
-> [VkDebugUtilsMessengerCreateFlagsEXT]
VkDebugUtilsMessengerCreateFlagsEXT
-> VkDebugUtilsMessengerCreateFlagsEXT
VkDebugUtilsMessengerCreateFlagsEXT
-> VkDebugUtilsMessengerCreateFlagsEXT
-> [VkDebugUtilsMessengerCreateFlagsEXT]
VkDebugUtilsMessengerCreateFlagsEXT
-> VkDebugUtilsMessengerCreateFlagsEXT
-> VkDebugUtilsMessengerCreateFlagsEXT
-> [VkDebugUtilsMessengerCreateFlagsEXT]
(VkDebugUtilsMessengerCreateFlagsEXT
 -> VkDebugUtilsMessengerCreateFlagsEXT)
-> (VkDebugUtilsMessengerCreateFlagsEXT
    -> VkDebugUtilsMessengerCreateFlagsEXT)
-> (Int -> VkDebugUtilsMessengerCreateFlagsEXT)
-> (VkDebugUtilsMessengerCreateFlagsEXT -> Int)
-> (VkDebugUtilsMessengerCreateFlagsEXT
    -> [VkDebugUtilsMessengerCreateFlagsEXT])
-> (VkDebugUtilsMessengerCreateFlagsEXT
    -> VkDebugUtilsMessengerCreateFlagsEXT
    -> [VkDebugUtilsMessengerCreateFlagsEXT])
-> (VkDebugUtilsMessengerCreateFlagsEXT
    -> VkDebugUtilsMessengerCreateFlagsEXT
    -> [VkDebugUtilsMessengerCreateFlagsEXT])
-> (VkDebugUtilsMessengerCreateFlagsEXT
    -> VkDebugUtilsMessengerCreateFlagsEXT
    -> VkDebugUtilsMessengerCreateFlagsEXT
    -> [VkDebugUtilsMessengerCreateFlagsEXT])
-> Enum VkDebugUtilsMessengerCreateFlagsEXT
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: VkDebugUtilsMessengerCreateFlagsEXT
-> VkDebugUtilsMessengerCreateFlagsEXT
-> VkDebugUtilsMessengerCreateFlagsEXT
-> [VkDebugUtilsMessengerCreateFlagsEXT]
$cenumFromThenTo :: VkDebugUtilsMessengerCreateFlagsEXT
-> VkDebugUtilsMessengerCreateFlagsEXT
-> VkDebugUtilsMessengerCreateFlagsEXT
-> [VkDebugUtilsMessengerCreateFlagsEXT]
enumFromTo :: VkDebugUtilsMessengerCreateFlagsEXT
-> VkDebugUtilsMessengerCreateFlagsEXT
-> [VkDebugUtilsMessengerCreateFlagsEXT]
$cenumFromTo :: VkDebugUtilsMessengerCreateFlagsEXT
-> VkDebugUtilsMessengerCreateFlagsEXT
-> [VkDebugUtilsMessengerCreateFlagsEXT]
enumFromThen :: VkDebugUtilsMessengerCreateFlagsEXT
-> VkDebugUtilsMessengerCreateFlagsEXT
-> [VkDebugUtilsMessengerCreateFlagsEXT]
$cenumFromThen :: VkDebugUtilsMessengerCreateFlagsEXT
-> VkDebugUtilsMessengerCreateFlagsEXT
-> [VkDebugUtilsMessengerCreateFlagsEXT]
enumFrom :: VkDebugUtilsMessengerCreateFlagsEXT
-> [VkDebugUtilsMessengerCreateFlagsEXT]
$cenumFrom :: VkDebugUtilsMessengerCreateFlagsEXT
-> [VkDebugUtilsMessengerCreateFlagsEXT]
fromEnum :: VkDebugUtilsMessengerCreateFlagsEXT -> Int
$cfromEnum :: VkDebugUtilsMessengerCreateFlagsEXT -> Int
toEnum :: Int -> VkDebugUtilsMessengerCreateFlagsEXT
$ctoEnum :: Int -> VkDebugUtilsMessengerCreateFlagsEXT
pred :: VkDebugUtilsMessengerCreateFlagsEXT
-> VkDebugUtilsMessengerCreateFlagsEXT
$cpred :: VkDebugUtilsMessengerCreateFlagsEXT
-> VkDebugUtilsMessengerCreateFlagsEXT
succ :: VkDebugUtilsMessengerCreateFlagsEXT
-> VkDebugUtilsMessengerCreateFlagsEXT
$csucc :: VkDebugUtilsMessengerCreateFlagsEXT
-> VkDebugUtilsMessengerCreateFlagsEXT
Enum, Eq VkDebugUtilsMessengerCreateFlagsEXT
VkDebugUtilsMessengerCreateFlagsEXT
Eq VkDebugUtilsMessengerCreateFlagsEXT
-> (VkDebugUtilsMessengerCreateFlagsEXT
    -> VkDebugUtilsMessengerCreateFlagsEXT
    -> VkDebugUtilsMessengerCreateFlagsEXT)
-> (VkDebugUtilsMessengerCreateFlagsEXT
    -> VkDebugUtilsMessengerCreateFlagsEXT
    -> VkDebugUtilsMessengerCreateFlagsEXT)
-> (VkDebugUtilsMessengerCreateFlagsEXT
    -> VkDebugUtilsMessengerCreateFlagsEXT
    -> VkDebugUtilsMessengerCreateFlagsEXT)
-> (VkDebugUtilsMessengerCreateFlagsEXT
    -> VkDebugUtilsMessengerCreateFlagsEXT)
-> (VkDebugUtilsMessengerCreateFlagsEXT
    -> Int -> VkDebugUtilsMessengerCreateFlagsEXT)
-> (VkDebugUtilsMessengerCreateFlagsEXT
    -> Int -> VkDebugUtilsMessengerCreateFlagsEXT)
-> VkDebugUtilsMessengerCreateFlagsEXT
-> (Int -> VkDebugUtilsMessengerCreateFlagsEXT)
-> (VkDebugUtilsMessengerCreateFlagsEXT
    -> Int -> VkDebugUtilsMessengerCreateFlagsEXT)
-> (VkDebugUtilsMessengerCreateFlagsEXT
    -> Int -> VkDebugUtilsMessengerCreateFlagsEXT)
-> (VkDebugUtilsMessengerCreateFlagsEXT
    -> Int -> VkDebugUtilsMessengerCreateFlagsEXT)
-> (VkDebugUtilsMessengerCreateFlagsEXT -> Int -> Bool)
-> (VkDebugUtilsMessengerCreateFlagsEXT -> Maybe Int)
-> (VkDebugUtilsMessengerCreateFlagsEXT -> Int)
-> (VkDebugUtilsMessengerCreateFlagsEXT -> Bool)
-> (VkDebugUtilsMessengerCreateFlagsEXT
    -> Int -> VkDebugUtilsMessengerCreateFlagsEXT)
-> (VkDebugUtilsMessengerCreateFlagsEXT
    -> Int -> VkDebugUtilsMessengerCreateFlagsEXT)
-> (VkDebugUtilsMessengerCreateFlagsEXT
    -> Int -> VkDebugUtilsMessengerCreateFlagsEXT)
-> (VkDebugUtilsMessengerCreateFlagsEXT
    -> Int -> VkDebugUtilsMessengerCreateFlagsEXT)
-> (VkDebugUtilsMessengerCreateFlagsEXT
    -> Int -> VkDebugUtilsMessengerCreateFlagsEXT)
-> (VkDebugUtilsMessengerCreateFlagsEXT
    -> Int -> VkDebugUtilsMessengerCreateFlagsEXT)
-> (VkDebugUtilsMessengerCreateFlagsEXT -> Int)
-> Bits VkDebugUtilsMessengerCreateFlagsEXT
Int -> VkDebugUtilsMessengerCreateFlagsEXT
VkDebugUtilsMessengerCreateFlagsEXT -> Bool
VkDebugUtilsMessengerCreateFlagsEXT -> Int
VkDebugUtilsMessengerCreateFlagsEXT -> Maybe Int
VkDebugUtilsMessengerCreateFlagsEXT
-> VkDebugUtilsMessengerCreateFlagsEXT
VkDebugUtilsMessengerCreateFlagsEXT -> Int -> Bool
VkDebugUtilsMessengerCreateFlagsEXT
-> Int -> VkDebugUtilsMessengerCreateFlagsEXT
VkDebugUtilsMessengerCreateFlagsEXT
-> VkDebugUtilsMessengerCreateFlagsEXT
-> VkDebugUtilsMessengerCreateFlagsEXT
forall a.
Eq a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
popCount :: VkDebugUtilsMessengerCreateFlagsEXT -> Int
$cpopCount :: VkDebugUtilsMessengerCreateFlagsEXT -> Int
rotateR :: VkDebugUtilsMessengerCreateFlagsEXT
-> Int -> VkDebugUtilsMessengerCreateFlagsEXT
$crotateR :: VkDebugUtilsMessengerCreateFlagsEXT
-> Int -> VkDebugUtilsMessengerCreateFlagsEXT
rotateL :: VkDebugUtilsMessengerCreateFlagsEXT
-> Int -> VkDebugUtilsMessengerCreateFlagsEXT
$crotateL :: VkDebugUtilsMessengerCreateFlagsEXT
-> Int -> VkDebugUtilsMessengerCreateFlagsEXT
unsafeShiftR :: VkDebugUtilsMessengerCreateFlagsEXT
-> Int -> VkDebugUtilsMessengerCreateFlagsEXT
$cunsafeShiftR :: VkDebugUtilsMessengerCreateFlagsEXT
-> Int -> VkDebugUtilsMessengerCreateFlagsEXT
shiftR :: VkDebugUtilsMessengerCreateFlagsEXT
-> Int -> VkDebugUtilsMessengerCreateFlagsEXT
$cshiftR :: VkDebugUtilsMessengerCreateFlagsEXT
-> Int -> VkDebugUtilsMessengerCreateFlagsEXT
unsafeShiftL :: VkDebugUtilsMessengerCreateFlagsEXT
-> Int -> VkDebugUtilsMessengerCreateFlagsEXT
$cunsafeShiftL :: VkDebugUtilsMessengerCreateFlagsEXT
-> Int -> VkDebugUtilsMessengerCreateFlagsEXT
shiftL :: VkDebugUtilsMessengerCreateFlagsEXT
-> Int -> VkDebugUtilsMessengerCreateFlagsEXT
$cshiftL :: VkDebugUtilsMessengerCreateFlagsEXT
-> Int -> VkDebugUtilsMessengerCreateFlagsEXT
isSigned :: VkDebugUtilsMessengerCreateFlagsEXT -> Bool
$cisSigned :: VkDebugUtilsMessengerCreateFlagsEXT -> Bool
bitSize :: VkDebugUtilsMessengerCreateFlagsEXT -> Int
$cbitSize :: VkDebugUtilsMessengerCreateFlagsEXT -> Int
bitSizeMaybe :: VkDebugUtilsMessengerCreateFlagsEXT -> Maybe Int
$cbitSizeMaybe :: VkDebugUtilsMessengerCreateFlagsEXT -> Maybe Int
testBit :: VkDebugUtilsMessengerCreateFlagsEXT -> Int -> Bool
$ctestBit :: VkDebugUtilsMessengerCreateFlagsEXT -> Int -> Bool
complementBit :: VkDebugUtilsMessengerCreateFlagsEXT
-> Int -> VkDebugUtilsMessengerCreateFlagsEXT
$ccomplementBit :: VkDebugUtilsMessengerCreateFlagsEXT
-> Int -> VkDebugUtilsMessengerCreateFlagsEXT
clearBit :: VkDebugUtilsMessengerCreateFlagsEXT
-> Int -> VkDebugUtilsMessengerCreateFlagsEXT
$cclearBit :: VkDebugUtilsMessengerCreateFlagsEXT
-> Int -> VkDebugUtilsMessengerCreateFlagsEXT
setBit :: VkDebugUtilsMessengerCreateFlagsEXT
-> Int -> VkDebugUtilsMessengerCreateFlagsEXT
$csetBit :: VkDebugUtilsMessengerCreateFlagsEXT
-> Int -> VkDebugUtilsMessengerCreateFlagsEXT
bit :: Int -> VkDebugUtilsMessengerCreateFlagsEXT
$cbit :: Int -> VkDebugUtilsMessengerCreateFlagsEXT
zeroBits :: VkDebugUtilsMessengerCreateFlagsEXT
$czeroBits :: VkDebugUtilsMessengerCreateFlagsEXT
rotate :: VkDebugUtilsMessengerCreateFlagsEXT
-> Int -> VkDebugUtilsMessengerCreateFlagsEXT
$crotate :: VkDebugUtilsMessengerCreateFlagsEXT
-> Int -> VkDebugUtilsMessengerCreateFlagsEXT
shift :: VkDebugUtilsMessengerCreateFlagsEXT
-> Int -> VkDebugUtilsMessengerCreateFlagsEXT
$cshift :: VkDebugUtilsMessengerCreateFlagsEXT
-> Int -> VkDebugUtilsMessengerCreateFlagsEXT
complement :: VkDebugUtilsMessengerCreateFlagsEXT
-> VkDebugUtilsMessengerCreateFlagsEXT
$ccomplement :: VkDebugUtilsMessengerCreateFlagsEXT
-> VkDebugUtilsMessengerCreateFlagsEXT
xor :: VkDebugUtilsMessengerCreateFlagsEXT
-> VkDebugUtilsMessengerCreateFlagsEXT
-> VkDebugUtilsMessengerCreateFlagsEXT
$cxor :: VkDebugUtilsMessengerCreateFlagsEXT
-> VkDebugUtilsMessengerCreateFlagsEXT
-> VkDebugUtilsMessengerCreateFlagsEXT
.|. :: VkDebugUtilsMessengerCreateFlagsEXT
-> VkDebugUtilsMessengerCreateFlagsEXT
-> VkDebugUtilsMessengerCreateFlagsEXT
$c.|. :: VkDebugUtilsMessengerCreateFlagsEXT
-> VkDebugUtilsMessengerCreateFlagsEXT
-> VkDebugUtilsMessengerCreateFlagsEXT
.&. :: VkDebugUtilsMessengerCreateFlagsEXT
-> VkDebugUtilsMessengerCreateFlagsEXT
-> VkDebugUtilsMessengerCreateFlagsEXT
$c.&. :: VkDebugUtilsMessengerCreateFlagsEXT
-> VkDebugUtilsMessengerCreateFlagsEXT
-> VkDebugUtilsMessengerCreateFlagsEXT
Bits, Bits VkDebugUtilsMessengerCreateFlagsEXT
Bits VkDebugUtilsMessengerCreateFlagsEXT
-> (VkDebugUtilsMessengerCreateFlagsEXT -> Int)
-> (VkDebugUtilsMessengerCreateFlagsEXT -> Int)
-> (VkDebugUtilsMessengerCreateFlagsEXT -> Int)
-> FiniteBits VkDebugUtilsMessengerCreateFlagsEXT
VkDebugUtilsMessengerCreateFlagsEXT -> Int
forall b.
Bits b -> (b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
countTrailingZeros :: VkDebugUtilsMessengerCreateFlagsEXT -> Int
$ccountTrailingZeros :: VkDebugUtilsMessengerCreateFlagsEXT -> Int
countLeadingZeros :: VkDebugUtilsMessengerCreateFlagsEXT -> Int
$ccountLeadingZeros :: VkDebugUtilsMessengerCreateFlagsEXT -> Int
finiteBitSize :: VkDebugUtilsMessengerCreateFlagsEXT -> Int
$cfiniteBitSize :: VkDebugUtilsMessengerCreateFlagsEXT -> Int
FiniteBits, Ptr VkDebugUtilsMessengerCreateFlagsEXT
-> IO VkDebugUtilsMessengerCreateFlagsEXT
Ptr VkDebugUtilsMessengerCreateFlagsEXT
-> Int -> IO VkDebugUtilsMessengerCreateFlagsEXT
Ptr VkDebugUtilsMessengerCreateFlagsEXT
-> Int -> VkDebugUtilsMessengerCreateFlagsEXT -> IO ()
Ptr VkDebugUtilsMessengerCreateFlagsEXT
-> VkDebugUtilsMessengerCreateFlagsEXT -> IO ()
VkDebugUtilsMessengerCreateFlagsEXT -> Int
(VkDebugUtilsMessengerCreateFlagsEXT -> Int)
-> (VkDebugUtilsMessengerCreateFlagsEXT -> Int)
-> (Ptr VkDebugUtilsMessengerCreateFlagsEXT
    -> Int -> IO VkDebugUtilsMessengerCreateFlagsEXT)
-> (Ptr VkDebugUtilsMessengerCreateFlagsEXT
    -> Int -> VkDebugUtilsMessengerCreateFlagsEXT -> IO ())
-> (forall b.
    Ptr b -> Int -> IO VkDebugUtilsMessengerCreateFlagsEXT)
-> (forall b.
    Ptr b -> Int -> VkDebugUtilsMessengerCreateFlagsEXT -> IO ())
-> (Ptr VkDebugUtilsMessengerCreateFlagsEXT
    -> IO VkDebugUtilsMessengerCreateFlagsEXT)
-> (Ptr VkDebugUtilsMessengerCreateFlagsEXT
    -> VkDebugUtilsMessengerCreateFlagsEXT -> IO ())
-> Storable VkDebugUtilsMessengerCreateFlagsEXT
forall b. Ptr b -> Int -> IO VkDebugUtilsMessengerCreateFlagsEXT
forall b.
Ptr b -> Int -> VkDebugUtilsMessengerCreateFlagsEXT -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr VkDebugUtilsMessengerCreateFlagsEXT
-> VkDebugUtilsMessengerCreateFlagsEXT -> IO ()
$cpoke :: Ptr VkDebugUtilsMessengerCreateFlagsEXT
-> VkDebugUtilsMessengerCreateFlagsEXT -> IO ()
peek :: Ptr VkDebugUtilsMessengerCreateFlagsEXT
-> IO VkDebugUtilsMessengerCreateFlagsEXT
$cpeek :: Ptr VkDebugUtilsMessengerCreateFlagsEXT
-> IO VkDebugUtilsMessengerCreateFlagsEXT
pokeByteOff :: forall b.
Ptr b -> Int -> VkDebugUtilsMessengerCreateFlagsEXT -> IO ()
$cpokeByteOff :: forall b.
Ptr b -> Int -> VkDebugUtilsMessengerCreateFlagsEXT -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO VkDebugUtilsMessengerCreateFlagsEXT
$cpeekByteOff :: forall b. Ptr b -> Int -> IO VkDebugUtilsMessengerCreateFlagsEXT
pokeElemOff :: Ptr VkDebugUtilsMessengerCreateFlagsEXT
-> Int -> VkDebugUtilsMessengerCreateFlagsEXT -> IO ()
$cpokeElemOff :: Ptr VkDebugUtilsMessengerCreateFlagsEXT
-> Int -> VkDebugUtilsMessengerCreateFlagsEXT -> IO ()
peekElemOff :: Ptr VkDebugUtilsMessengerCreateFlagsEXT
-> Int -> IO VkDebugUtilsMessengerCreateFlagsEXT
$cpeekElemOff :: Ptr VkDebugUtilsMessengerCreateFlagsEXT
-> Int -> IO VkDebugUtilsMessengerCreateFlagsEXT
alignment :: VkDebugUtilsMessengerCreateFlagsEXT -> Int
$calignment :: VkDebugUtilsMessengerCreateFlagsEXT -> Int
sizeOf :: VkDebugUtilsMessengerCreateFlagsEXT -> Int
$csizeOf :: VkDebugUtilsMessengerCreateFlagsEXT -> Int
Storable)

instance Show VkDebugUtilsMessengerCreateFlagsEXT where
    {-# INLINE showsPrec #-}
    showsPrec :: Int -> VkDebugUtilsMessengerCreateFlagsEXT -> ShowS
showsPrec = (Int -> VkFlags -> ShowS)
-> Int -> VkDebugUtilsMessengerCreateFlagsEXT -> ShowS
coerce (Int -> VkFlags -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec :: Int -> VkFlags -> ShowS)

instance Read VkDebugUtilsMessengerCreateFlagsEXT where
    {-# INLINE readsPrec #-}
    readsPrec :: Int -> ReadS VkDebugUtilsMessengerCreateFlagsEXT
readsPrec = (Int -> ReadS VkFlags)
-> Int -> ReadS VkDebugUtilsMessengerCreateFlagsEXT
coerce (Int -> ReadS VkFlags
forall a. Read a => Int -> ReadS a
readsPrec :: Int -> ReadS VkFlags)

newtype VkDescriptorBindingFlagsEXT = VkDescriptorBindingFlagsEXT VkFlags
                                      deriving (VkDescriptorBindingFlagsEXT -> VkDescriptorBindingFlagsEXT -> Bool
(VkDescriptorBindingFlagsEXT
 -> VkDescriptorBindingFlagsEXT -> Bool)
-> (VkDescriptorBindingFlagsEXT
    -> VkDescriptorBindingFlagsEXT -> Bool)
-> Eq VkDescriptorBindingFlagsEXT
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VkDescriptorBindingFlagsEXT -> VkDescriptorBindingFlagsEXT -> Bool
$c/= :: VkDescriptorBindingFlagsEXT -> VkDescriptorBindingFlagsEXT -> Bool
== :: VkDescriptorBindingFlagsEXT -> VkDescriptorBindingFlagsEXT -> Bool
$c== :: VkDescriptorBindingFlagsEXT -> VkDescriptorBindingFlagsEXT -> Bool
Eq, Eq VkDescriptorBindingFlagsEXT
Eq VkDescriptorBindingFlagsEXT
-> (VkDescriptorBindingFlagsEXT
    -> VkDescriptorBindingFlagsEXT -> Ordering)
-> (VkDescriptorBindingFlagsEXT
    -> VkDescriptorBindingFlagsEXT -> Bool)
-> (VkDescriptorBindingFlagsEXT
    -> VkDescriptorBindingFlagsEXT -> Bool)
-> (VkDescriptorBindingFlagsEXT
    -> VkDescriptorBindingFlagsEXT -> Bool)
-> (VkDescriptorBindingFlagsEXT
    -> VkDescriptorBindingFlagsEXT -> Bool)
-> (VkDescriptorBindingFlagsEXT
    -> VkDescriptorBindingFlagsEXT -> VkDescriptorBindingFlagsEXT)
-> (VkDescriptorBindingFlagsEXT
    -> VkDescriptorBindingFlagsEXT -> VkDescriptorBindingFlagsEXT)
-> Ord VkDescriptorBindingFlagsEXT
VkDescriptorBindingFlagsEXT -> VkDescriptorBindingFlagsEXT -> Bool
VkDescriptorBindingFlagsEXT
-> VkDescriptorBindingFlagsEXT -> Ordering
VkDescriptorBindingFlagsEXT
-> VkDescriptorBindingFlagsEXT -> VkDescriptorBindingFlagsEXT
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: VkDescriptorBindingFlagsEXT
-> VkDescriptorBindingFlagsEXT -> VkDescriptorBindingFlagsEXT
$cmin :: VkDescriptorBindingFlagsEXT
-> VkDescriptorBindingFlagsEXT -> VkDescriptorBindingFlagsEXT
max :: VkDescriptorBindingFlagsEXT
-> VkDescriptorBindingFlagsEXT -> VkDescriptorBindingFlagsEXT
$cmax :: VkDescriptorBindingFlagsEXT
-> VkDescriptorBindingFlagsEXT -> VkDescriptorBindingFlagsEXT
>= :: VkDescriptorBindingFlagsEXT -> VkDescriptorBindingFlagsEXT -> Bool
$c>= :: VkDescriptorBindingFlagsEXT -> VkDescriptorBindingFlagsEXT -> Bool
> :: VkDescriptorBindingFlagsEXT -> VkDescriptorBindingFlagsEXT -> Bool
$c> :: VkDescriptorBindingFlagsEXT -> VkDescriptorBindingFlagsEXT -> Bool
<= :: VkDescriptorBindingFlagsEXT -> VkDescriptorBindingFlagsEXT -> Bool
$c<= :: VkDescriptorBindingFlagsEXT -> VkDescriptorBindingFlagsEXT -> Bool
< :: VkDescriptorBindingFlagsEXT -> VkDescriptorBindingFlagsEXT -> Bool
$c< :: VkDescriptorBindingFlagsEXT -> VkDescriptorBindingFlagsEXT -> Bool
compare :: VkDescriptorBindingFlagsEXT
-> VkDescriptorBindingFlagsEXT -> Ordering
$ccompare :: VkDescriptorBindingFlagsEXT
-> VkDescriptorBindingFlagsEXT -> Ordering
Ord, Int -> VkDescriptorBindingFlagsEXT
VkDescriptorBindingFlagsEXT -> Int
VkDescriptorBindingFlagsEXT -> [VkDescriptorBindingFlagsEXT]
VkDescriptorBindingFlagsEXT -> VkDescriptorBindingFlagsEXT
VkDescriptorBindingFlagsEXT
-> VkDescriptorBindingFlagsEXT -> [VkDescriptorBindingFlagsEXT]
VkDescriptorBindingFlagsEXT
-> VkDescriptorBindingFlagsEXT
-> VkDescriptorBindingFlagsEXT
-> [VkDescriptorBindingFlagsEXT]
(VkDescriptorBindingFlagsEXT -> VkDescriptorBindingFlagsEXT)
-> (VkDescriptorBindingFlagsEXT -> VkDescriptorBindingFlagsEXT)
-> (Int -> VkDescriptorBindingFlagsEXT)
-> (VkDescriptorBindingFlagsEXT -> Int)
-> (VkDescriptorBindingFlagsEXT -> [VkDescriptorBindingFlagsEXT])
-> (VkDescriptorBindingFlagsEXT
    -> VkDescriptorBindingFlagsEXT -> [VkDescriptorBindingFlagsEXT])
-> (VkDescriptorBindingFlagsEXT
    -> VkDescriptorBindingFlagsEXT -> [VkDescriptorBindingFlagsEXT])
-> (VkDescriptorBindingFlagsEXT
    -> VkDescriptorBindingFlagsEXT
    -> VkDescriptorBindingFlagsEXT
    -> [VkDescriptorBindingFlagsEXT])
-> Enum VkDescriptorBindingFlagsEXT
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: VkDescriptorBindingFlagsEXT
-> VkDescriptorBindingFlagsEXT
-> VkDescriptorBindingFlagsEXT
-> [VkDescriptorBindingFlagsEXT]
$cenumFromThenTo :: VkDescriptorBindingFlagsEXT
-> VkDescriptorBindingFlagsEXT
-> VkDescriptorBindingFlagsEXT
-> [VkDescriptorBindingFlagsEXT]
enumFromTo :: VkDescriptorBindingFlagsEXT
-> VkDescriptorBindingFlagsEXT -> [VkDescriptorBindingFlagsEXT]
$cenumFromTo :: VkDescriptorBindingFlagsEXT
-> VkDescriptorBindingFlagsEXT -> [VkDescriptorBindingFlagsEXT]
enumFromThen :: VkDescriptorBindingFlagsEXT
-> VkDescriptorBindingFlagsEXT -> [VkDescriptorBindingFlagsEXT]
$cenumFromThen :: VkDescriptorBindingFlagsEXT
-> VkDescriptorBindingFlagsEXT -> [VkDescriptorBindingFlagsEXT]
enumFrom :: VkDescriptorBindingFlagsEXT -> [VkDescriptorBindingFlagsEXT]
$cenumFrom :: VkDescriptorBindingFlagsEXT -> [VkDescriptorBindingFlagsEXT]
fromEnum :: VkDescriptorBindingFlagsEXT -> Int
$cfromEnum :: VkDescriptorBindingFlagsEXT -> Int
toEnum :: Int -> VkDescriptorBindingFlagsEXT
$ctoEnum :: Int -> VkDescriptorBindingFlagsEXT
pred :: VkDescriptorBindingFlagsEXT -> VkDescriptorBindingFlagsEXT
$cpred :: VkDescriptorBindingFlagsEXT -> VkDescriptorBindingFlagsEXT
succ :: VkDescriptorBindingFlagsEXT -> VkDescriptorBindingFlagsEXT
$csucc :: VkDescriptorBindingFlagsEXT -> VkDescriptorBindingFlagsEXT
Enum, Eq VkDescriptorBindingFlagsEXT
VkDescriptorBindingFlagsEXT
Eq VkDescriptorBindingFlagsEXT
-> (VkDescriptorBindingFlagsEXT
    -> VkDescriptorBindingFlagsEXT -> VkDescriptorBindingFlagsEXT)
-> (VkDescriptorBindingFlagsEXT
    -> VkDescriptorBindingFlagsEXT -> VkDescriptorBindingFlagsEXT)
-> (VkDescriptorBindingFlagsEXT
    -> VkDescriptorBindingFlagsEXT -> VkDescriptorBindingFlagsEXT)
-> (VkDescriptorBindingFlagsEXT -> VkDescriptorBindingFlagsEXT)
-> (VkDescriptorBindingFlagsEXT
    -> Int -> VkDescriptorBindingFlagsEXT)
-> (VkDescriptorBindingFlagsEXT
    -> Int -> VkDescriptorBindingFlagsEXT)
-> VkDescriptorBindingFlagsEXT
-> (Int -> VkDescriptorBindingFlagsEXT)
-> (VkDescriptorBindingFlagsEXT
    -> Int -> VkDescriptorBindingFlagsEXT)
-> (VkDescriptorBindingFlagsEXT
    -> Int -> VkDescriptorBindingFlagsEXT)
-> (VkDescriptorBindingFlagsEXT
    -> Int -> VkDescriptorBindingFlagsEXT)
-> (VkDescriptorBindingFlagsEXT -> Int -> Bool)
-> (VkDescriptorBindingFlagsEXT -> Maybe Int)
-> (VkDescriptorBindingFlagsEXT -> Int)
-> (VkDescriptorBindingFlagsEXT -> Bool)
-> (VkDescriptorBindingFlagsEXT
    -> Int -> VkDescriptorBindingFlagsEXT)
-> (VkDescriptorBindingFlagsEXT
    -> Int -> VkDescriptorBindingFlagsEXT)
-> (VkDescriptorBindingFlagsEXT
    -> Int -> VkDescriptorBindingFlagsEXT)
-> (VkDescriptorBindingFlagsEXT
    -> Int -> VkDescriptorBindingFlagsEXT)
-> (VkDescriptorBindingFlagsEXT
    -> Int -> VkDescriptorBindingFlagsEXT)
-> (VkDescriptorBindingFlagsEXT
    -> Int -> VkDescriptorBindingFlagsEXT)
-> (VkDescriptorBindingFlagsEXT -> Int)
-> Bits VkDescriptorBindingFlagsEXT
Int -> VkDescriptorBindingFlagsEXT
VkDescriptorBindingFlagsEXT -> Bool
VkDescriptorBindingFlagsEXT -> Int
VkDescriptorBindingFlagsEXT -> Maybe Int
VkDescriptorBindingFlagsEXT -> VkDescriptorBindingFlagsEXT
VkDescriptorBindingFlagsEXT -> Int -> Bool
VkDescriptorBindingFlagsEXT -> Int -> VkDescriptorBindingFlagsEXT
VkDescriptorBindingFlagsEXT
-> VkDescriptorBindingFlagsEXT -> VkDescriptorBindingFlagsEXT
forall a.
Eq a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
popCount :: VkDescriptorBindingFlagsEXT -> Int
$cpopCount :: VkDescriptorBindingFlagsEXT -> Int
rotateR :: VkDescriptorBindingFlagsEXT -> Int -> VkDescriptorBindingFlagsEXT
$crotateR :: VkDescriptorBindingFlagsEXT -> Int -> VkDescriptorBindingFlagsEXT
rotateL :: VkDescriptorBindingFlagsEXT -> Int -> VkDescriptorBindingFlagsEXT
$crotateL :: VkDescriptorBindingFlagsEXT -> Int -> VkDescriptorBindingFlagsEXT
unsafeShiftR :: VkDescriptorBindingFlagsEXT -> Int -> VkDescriptorBindingFlagsEXT
$cunsafeShiftR :: VkDescriptorBindingFlagsEXT -> Int -> VkDescriptorBindingFlagsEXT
shiftR :: VkDescriptorBindingFlagsEXT -> Int -> VkDescriptorBindingFlagsEXT
$cshiftR :: VkDescriptorBindingFlagsEXT -> Int -> VkDescriptorBindingFlagsEXT
unsafeShiftL :: VkDescriptorBindingFlagsEXT -> Int -> VkDescriptorBindingFlagsEXT
$cunsafeShiftL :: VkDescriptorBindingFlagsEXT -> Int -> VkDescriptorBindingFlagsEXT
shiftL :: VkDescriptorBindingFlagsEXT -> Int -> VkDescriptorBindingFlagsEXT
$cshiftL :: VkDescriptorBindingFlagsEXT -> Int -> VkDescriptorBindingFlagsEXT
isSigned :: VkDescriptorBindingFlagsEXT -> Bool
$cisSigned :: VkDescriptorBindingFlagsEXT -> Bool
bitSize :: VkDescriptorBindingFlagsEXT -> Int
$cbitSize :: VkDescriptorBindingFlagsEXT -> Int
bitSizeMaybe :: VkDescriptorBindingFlagsEXT -> Maybe Int
$cbitSizeMaybe :: VkDescriptorBindingFlagsEXT -> Maybe Int
testBit :: VkDescriptorBindingFlagsEXT -> Int -> Bool
$ctestBit :: VkDescriptorBindingFlagsEXT -> Int -> Bool
complementBit :: VkDescriptorBindingFlagsEXT -> Int -> VkDescriptorBindingFlagsEXT
$ccomplementBit :: VkDescriptorBindingFlagsEXT -> Int -> VkDescriptorBindingFlagsEXT
clearBit :: VkDescriptorBindingFlagsEXT -> Int -> VkDescriptorBindingFlagsEXT
$cclearBit :: VkDescriptorBindingFlagsEXT -> Int -> VkDescriptorBindingFlagsEXT
setBit :: VkDescriptorBindingFlagsEXT -> Int -> VkDescriptorBindingFlagsEXT
$csetBit :: VkDescriptorBindingFlagsEXT -> Int -> VkDescriptorBindingFlagsEXT
bit :: Int -> VkDescriptorBindingFlagsEXT
$cbit :: Int -> VkDescriptorBindingFlagsEXT
zeroBits :: VkDescriptorBindingFlagsEXT
$czeroBits :: VkDescriptorBindingFlagsEXT
rotate :: VkDescriptorBindingFlagsEXT -> Int -> VkDescriptorBindingFlagsEXT
$crotate :: VkDescriptorBindingFlagsEXT -> Int -> VkDescriptorBindingFlagsEXT
shift :: VkDescriptorBindingFlagsEXT -> Int -> VkDescriptorBindingFlagsEXT
$cshift :: VkDescriptorBindingFlagsEXT -> Int -> VkDescriptorBindingFlagsEXT
complement :: VkDescriptorBindingFlagsEXT -> VkDescriptorBindingFlagsEXT
$ccomplement :: VkDescriptorBindingFlagsEXT -> VkDescriptorBindingFlagsEXT
xor :: VkDescriptorBindingFlagsEXT
-> VkDescriptorBindingFlagsEXT -> VkDescriptorBindingFlagsEXT
$cxor :: VkDescriptorBindingFlagsEXT
-> VkDescriptorBindingFlagsEXT -> VkDescriptorBindingFlagsEXT
.|. :: VkDescriptorBindingFlagsEXT
-> VkDescriptorBindingFlagsEXT -> VkDescriptorBindingFlagsEXT
$c.|. :: VkDescriptorBindingFlagsEXT
-> VkDescriptorBindingFlagsEXT -> VkDescriptorBindingFlagsEXT
.&. :: VkDescriptorBindingFlagsEXT
-> VkDescriptorBindingFlagsEXT -> VkDescriptorBindingFlagsEXT
$c.&. :: VkDescriptorBindingFlagsEXT
-> VkDescriptorBindingFlagsEXT -> VkDescriptorBindingFlagsEXT
Bits, Bits VkDescriptorBindingFlagsEXT
Bits VkDescriptorBindingFlagsEXT
-> (VkDescriptorBindingFlagsEXT -> Int)
-> (VkDescriptorBindingFlagsEXT -> Int)
-> (VkDescriptorBindingFlagsEXT -> Int)
-> FiniteBits VkDescriptorBindingFlagsEXT
VkDescriptorBindingFlagsEXT -> Int
forall b.
Bits b -> (b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
countTrailingZeros :: VkDescriptorBindingFlagsEXT -> Int
$ccountTrailingZeros :: VkDescriptorBindingFlagsEXT -> Int
countLeadingZeros :: VkDescriptorBindingFlagsEXT -> Int
$ccountLeadingZeros :: VkDescriptorBindingFlagsEXT -> Int
finiteBitSize :: VkDescriptorBindingFlagsEXT -> Int
$cfiniteBitSize :: VkDescriptorBindingFlagsEXT -> Int
FiniteBits, Ptr VkDescriptorBindingFlagsEXT -> IO VkDescriptorBindingFlagsEXT
Ptr VkDescriptorBindingFlagsEXT
-> Int -> IO VkDescriptorBindingFlagsEXT
Ptr VkDescriptorBindingFlagsEXT
-> Int -> VkDescriptorBindingFlagsEXT -> IO ()
Ptr VkDescriptorBindingFlagsEXT
-> VkDescriptorBindingFlagsEXT -> IO ()
VkDescriptorBindingFlagsEXT -> Int
(VkDescriptorBindingFlagsEXT -> Int)
-> (VkDescriptorBindingFlagsEXT -> Int)
-> (Ptr VkDescriptorBindingFlagsEXT
    -> Int -> IO VkDescriptorBindingFlagsEXT)
-> (Ptr VkDescriptorBindingFlagsEXT
    -> Int -> VkDescriptorBindingFlagsEXT -> IO ())
-> (forall b. Ptr b -> Int -> IO VkDescriptorBindingFlagsEXT)
-> (forall b. Ptr b -> Int -> VkDescriptorBindingFlagsEXT -> IO ())
-> (Ptr VkDescriptorBindingFlagsEXT
    -> IO VkDescriptorBindingFlagsEXT)
-> (Ptr VkDescriptorBindingFlagsEXT
    -> VkDescriptorBindingFlagsEXT -> IO ())
-> Storable VkDescriptorBindingFlagsEXT
forall b. Ptr b -> Int -> IO VkDescriptorBindingFlagsEXT
forall b. Ptr b -> Int -> VkDescriptorBindingFlagsEXT -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr VkDescriptorBindingFlagsEXT
-> VkDescriptorBindingFlagsEXT -> IO ()
$cpoke :: Ptr VkDescriptorBindingFlagsEXT
-> VkDescriptorBindingFlagsEXT -> IO ()
peek :: Ptr VkDescriptorBindingFlagsEXT -> IO VkDescriptorBindingFlagsEXT
$cpeek :: Ptr VkDescriptorBindingFlagsEXT -> IO VkDescriptorBindingFlagsEXT
pokeByteOff :: forall b. Ptr b -> Int -> VkDescriptorBindingFlagsEXT -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> VkDescriptorBindingFlagsEXT -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO VkDescriptorBindingFlagsEXT
$cpeekByteOff :: forall b. Ptr b -> Int -> IO VkDescriptorBindingFlagsEXT
pokeElemOff :: Ptr VkDescriptorBindingFlagsEXT
-> Int -> VkDescriptorBindingFlagsEXT -> IO ()
$cpokeElemOff :: Ptr VkDescriptorBindingFlagsEXT
-> Int -> VkDescriptorBindingFlagsEXT -> IO ()
peekElemOff :: Ptr VkDescriptorBindingFlagsEXT
-> Int -> IO VkDescriptorBindingFlagsEXT
$cpeekElemOff :: Ptr VkDescriptorBindingFlagsEXT
-> Int -> IO VkDescriptorBindingFlagsEXT
alignment :: VkDescriptorBindingFlagsEXT -> Int
$calignment :: VkDescriptorBindingFlagsEXT -> Int
sizeOf :: VkDescriptorBindingFlagsEXT -> Int
$csizeOf :: VkDescriptorBindingFlagsEXT -> Int
Storable)

instance Show VkDescriptorBindingFlagsEXT where
    {-# INLINE showsPrec #-}
    showsPrec :: Int -> VkDescriptorBindingFlagsEXT -> ShowS
showsPrec = (Int -> VkFlags -> ShowS)
-> Int -> VkDescriptorBindingFlagsEXT -> ShowS
coerce (Int -> VkFlags -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec :: Int -> VkFlags -> ShowS)

instance Read VkDescriptorBindingFlagsEXT where
    {-# INLINE readsPrec #-}
    readsPrec :: Int -> ReadS VkDescriptorBindingFlagsEXT
readsPrec = (Int -> ReadS VkFlags) -> Int -> ReadS VkDescriptorBindingFlagsEXT
coerce (Int -> ReadS VkFlags
forall a. Read a => Int -> ReadS a
readsPrec :: Int -> ReadS VkFlags)

newtype VkDescriptorPoolResetFlags = VkDescriptorPoolResetFlags VkFlags
                                     deriving (VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags -> Bool
(VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags -> Bool)
-> (VkDescriptorPoolResetFlags
    -> VkDescriptorPoolResetFlags -> Bool)
-> Eq VkDescriptorPoolResetFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags -> Bool
$c/= :: VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags -> Bool
== :: VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags -> Bool
$c== :: VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags -> Bool
Eq, Eq VkDescriptorPoolResetFlags
Eq VkDescriptorPoolResetFlags
-> (VkDescriptorPoolResetFlags
    -> VkDescriptorPoolResetFlags -> Ordering)
-> (VkDescriptorPoolResetFlags
    -> VkDescriptorPoolResetFlags -> Bool)
-> (VkDescriptorPoolResetFlags
    -> VkDescriptorPoolResetFlags -> Bool)
-> (VkDescriptorPoolResetFlags
    -> VkDescriptorPoolResetFlags -> Bool)
-> (VkDescriptorPoolResetFlags
    -> VkDescriptorPoolResetFlags -> Bool)
-> (VkDescriptorPoolResetFlags
    -> VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags)
-> (VkDescriptorPoolResetFlags
    -> VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags)
-> Ord VkDescriptorPoolResetFlags
VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags -> Bool
VkDescriptorPoolResetFlags
-> VkDescriptorPoolResetFlags -> Ordering
VkDescriptorPoolResetFlags
-> VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: VkDescriptorPoolResetFlags
-> VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags
$cmin :: VkDescriptorPoolResetFlags
-> VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags
max :: VkDescriptorPoolResetFlags
-> VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags
$cmax :: VkDescriptorPoolResetFlags
-> VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags
>= :: VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags -> Bool
$c>= :: VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags -> Bool
> :: VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags -> Bool
$c> :: VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags -> Bool
<= :: VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags -> Bool
$c<= :: VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags -> Bool
< :: VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags -> Bool
$c< :: VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags -> Bool
compare :: VkDescriptorPoolResetFlags
-> VkDescriptorPoolResetFlags -> Ordering
$ccompare :: VkDescriptorPoolResetFlags
-> VkDescriptorPoolResetFlags -> Ordering
Ord, Int -> VkDescriptorPoolResetFlags
VkDescriptorPoolResetFlags -> Int
VkDescriptorPoolResetFlags -> [VkDescriptorPoolResetFlags]
VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags
VkDescriptorPoolResetFlags
-> VkDescriptorPoolResetFlags -> [VkDescriptorPoolResetFlags]
VkDescriptorPoolResetFlags
-> VkDescriptorPoolResetFlags
-> VkDescriptorPoolResetFlags
-> [VkDescriptorPoolResetFlags]
(VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags)
-> (VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags)
-> (Int -> VkDescriptorPoolResetFlags)
-> (VkDescriptorPoolResetFlags -> Int)
-> (VkDescriptorPoolResetFlags -> [VkDescriptorPoolResetFlags])
-> (VkDescriptorPoolResetFlags
    -> VkDescriptorPoolResetFlags -> [VkDescriptorPoolResetFlags])
-> (VkDescriptorPoolResetFlags
    -> VkDescriptorPoolResetFlags -> [VkDescriptorPoolResetFlags])
-> (VkDescriptorPoolResetFlags
    -> VkDescriptorPoolResetFlags
    -> VkDescriptorPoolResetFlags
    -> [VkDescriptorPoolResetFlags])
-> Enum VkDescriptorPoolResetFlags
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: VkDescriptorPoolResetFlags
-> VkDescriptorPoolResetFlags
-> VkDescriptorPoolResetFlags
-> [VkDescriptorPoolResetFlags]
$cenumFromThenTo :: VkDescriptorPoolResetFlags
-> VkDescriptorPoolResetFlags
-> VkDescriptorPoolResetFlags
-> [VkDescriptorPoolResetFlags]
enumFromTo :: VkDescriptorPoolResetFlags
-> VkDescriptorPoolResetFlags -> [VkDescriptorPoolResetFlags]
$cenumFromTo :: VkDescriptorPoolResetFlags
-> VkDescriptorPoolResetFlags -> [VkDescriptorPoolResetFlags]
enumFromThen :: VkDescriptorPoolResetFlags
-> VkDescriptorPoolResetFlags -> [VkDescriptorPoolResetFlags]
$cenumFromThen :: VkDescriptorPoolResetFlags
-> VkDescriptorPoolResetFlags -> [VkDescriptorPoolResetFlags]
enumFrom :: VkDescriptorPoolResetFlags -> [VkDescriptorPoolResetFlags]
$cenumFrom :: VkDescriptorPoolResetFlags -> [VkDescriptorPoolResetFlags]
fromEnum :: VkDescriptorPoolResetFlags -> Int
$cfromEnum :: VkDescriptorPoolResetFlags -> Int
toEnum :: Int -> VkDescriptorPoolResetFlags
$ctoEnum :: Int -> VkDescriptorPoolResetFlags
pred :: VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags
$cpred :: VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags
succ :: VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags
$csucc :: VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags
Enum, Eq VkDescriptorPoolResetFlags
VkDescriptorPoolResetFlags
Eq VkDescriptorPoolResetFlags
-> (VkDescriptorPoolResetFlags
    -> VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags)
-> (VkDescriptorPoolResetFlags
    -> VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags)
-> (VkDescriptorPoolResetFlags
    -> VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags)
-> (VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags)
-> (VkDescriptorPoolResetFlags
    -> Int -> VkDescriptorPoolResetFlags)
-> (VkDescriptorPoolResetFlags
    -> Int -> VkDescriptorPoolResetFlags)
-> VkDescriptorPoolResetFlags
-> (Int -> VkDescriptorPoolResetFlags)
-> (VkDescriptorPoolResetFlags
    -> Int -> VkDescriptorPoolResetFlags)
-> (VkDescriptorPoolResetFlags
    -> Int -> VkDescriptorPoolResetFlags)
-> (VkDescriptorPoolResetFlags
    -> Int -> VkDescriptorPoolResetFlags)
-> (VkDescriptorPoolResetFlags -> Int -> Bool)
-> (VkDescriptorPoolResetFlags -> Maybe Int)
-> (VkDescriptorPoolResetFlags -> Int)
-> (VkDescriptorPoolResetFlags -> Bool)
-> (VkDescriptorPoolResetFlags
    -> Int -> VkDescriptorPoolResetFlags)
-> (VkDescriptorPoolResetFlags
    -> Int -> VkDescriptorPoolResetFlags)
-> (VkDescriptorPoolResetFlags
    -> Int -> VkDescriptorPoolResetFlags)
-> (VkDescriptorPoolResetFlags
    -> Int -> VkDescriptorPoolResetFlags)
-> (VkDescriptorPoolResetFlags
    -> Int -> VkDescriptorPoolResetFlags)
-> (VkDescriptorPoolResetFlags
    -> Int -> VkDescriptorPoolResetFlags)
-> (VkDescriptorPoolResetFlags -> Int)
-> Bits VkDescriptorPoolResetFlags
Int -> VkDescriptorPoolResetFlags
VkDescriptorPoolResetFlags -> Bool
VkDescriptorPoolResetFlags -> Int
VkDescriptorPoolResetFlags -> Maybe Int
VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags
VkDescriptorPoolResetFlags -> Int -> Bool
VkDescriptorPoolResetFlags -> Int -> VkDescriptorPoolResetFlags
VkDescriptorPoolResetFlags
-> VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags
forall a.
Eq a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
popCount :: VkDescriptorPoolResetFlags -> Int
$cpopCount :: VkDescriptorPoolResetFlags -> Int
rotateR :: VkDescriptorPoolResetFlags -> Int -> VkDescriptorPoolResetFlags
$crotateR :: VkDescriptorPoolResetFlags -> Int -> VkDescriptorPoolResetFlags
rotateL :: VkDescriptorPoolResetFlags -> Int -> VkDescriptorPoolResetFlags
$crotateL :: VkDescriptorPoolResetFlags -> Int -> VkDescriptorPoolResetFlags
unsafeShiftR :: VkDescriptorPoolResetFlags -> Int -> VkDescriptorPoolResetFlags
$cunsafeShiftR :: VkDescriptorPoolResetFlags -> Int -> VkDescriptorPoolResetFlags
shiftR :: VkDescriptorPoolResetFlags -> Int -> VkDescriptorPoolResetFlags
$cshiftR :: VkDescriptorPoolResetFlags -> Int -> VkDescriptorPoolResetFlags
unsafeShiftL :: VkDescriptorPoolResetFlags -> Int -> VkDescriptorPoolResetFlags
$cunsafeShiftL :: VkDescriptorPoolResetFlags -> Int -> VkDescriptorPoolResetFlags
shiftL :: VkDescriptorPoolResetFlags -> Int -> VkDescriptorPoolResetFlags
$cshiftL :: VkDescriptorPoolResetFlags -> Int -> VkDescriptorPoolResetFlags
isSigned :: VkDescriptorPoolResetFlags -> Bool
$cisSigned :: VkDescriptorPoolResetFlags -> Bool
bitSize :: VkDescriptorPoolResetFlags -> Int
$cbitSize :: VkDescriptorPoolResetFlags -> Int
bitSizeMaybe :: VkDescriptorPoolResetFlags -> Maybe Int
$cbitSizeMaybe :: VkDescriptorPoolResetFlags -> Maybe Int
testBit :: VkDescriptorPoolResetFlags -> Int -> Bool
$ctestBit :: VkDescriptorPoolResetFlags -> Int -> Bool
complementBit :: VkDescriptorPoolResetFlags -> Int -> VkDescriptorPoolResetFlags
$ccomplementBit :: VkDescriptorPoolResetFlags -> Int -> VkDescriptorPoolResetFlags
clearBit :: VkDescriptorPoolResetFlags -> Int -> VkDescriptorPoolResetFlags
$cclearBit :: VkDescriptorPoolResetFlags -> Int -> VkDescriptorPoolResetFlags
setBit :: VkDescriptorPoolResetFlags -> Int -> VkDescriptorPoolResetFlags
$csetBit :: VkDescriptorPoolResetFlags -> Int -> VkDescriptorPoolResetFlags
bit :: Int -> VkDescriptorPoolResetFlags
$cbit :: Int -> VkDescriptorPoolResetFlags
zeroBits :: VkDescriptorPoolResetFlags
$czeroBits :: VkDescriptorPoolResetFlags
rotate :: VkDescriptorPoolResetFlags -> Int -> VkDescriptorPoolResetFlags
$crotate :: VkDescriptorPoolResetFlags -> Int -> VkDescriptorPoolResetFlags
shift :: VkDescriptorPoolResetFlags -> Int -> VkDescriptorPoolResetFlags
$cshift :: VkDescriptorPoolResetFlags -> Int -> VkDescriptorPoolResetFlags
complement :: VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags
$ccomplement :: VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags
xor :: VkDescriptorPoolResetFlags
-> VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags
$cxor :: VkDescriptorPoolResetFlags
-> VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags
.|. :: VkDescriptorPoolResetFlags
-> VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags
$c.|. :: VkDescriptorPoolResetFlags
-> VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags
.&. :: VkDescriptorPoolResetFlags
-> VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags
$c.&. :: VkDescriptorPoolResetFlags
-> VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags
Bits, Bits VkDescriptorPoolResetFlags
Bits VkDescriptorPoolResetFlags
-> (VkDescriptorPoolResetFlags -> Int)
-> (VkDescriptorPoolResetFlags -> Int)
-> (VkDescriptorPoolResetFlags -> Int)
-> FiniteBits VkDescriptorPoolResetFlags
VkDescriptorPoolResetFlags -> Int
forall b.
Bits b -> (b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
countTrailingZeros :: VkDescriptorPoolResetFlags -> Int
$ccountTrailingZeros :: VkDescriptorPoolResetFlags -> Int
countLeadingZeros :: VkDescriptorPoolResetFlags -> Int
$ccountLeadingZeros :: VkDescriptorPoolResetFlags -> Int
finiteBitSize :: VkDescriptorPoolResetFlags -> Int
$cfiniteBitSize :: VkDescriptorPoolResetFlags -> Int
FiniteBits, Ptr VkDescriptorPoolResetFlags -> IO VkDescriptorPoolResetFlags
Ptr VkDescriptorPoolResetFlags
-> Int -> IO VkDescriptorPoolResetFlags
Ptr VkDescriptorPoolResetFlags
-> Int -> VkDescriptorPoolResetFlags -> IO ()
Ptr VkDescriptorPoolResetFlags
-> VkDescriptorPoolResetFlags -> IO ()
VkDescriptorPoolResetFlags -> Int
(VkDescriptorPoolResetFlags -> Int)
-> (VkDescriptorPoolResetFlags -> Int)
-> (Ptr VkDescriptorPoolResetFlags
    -> Int -> IO VkDescriptorPoolResetFlags)
-> (Ptr VkDescriptorPoolResetFlags
    -> Int -> VkDescriptorPoolResetFlags -> IO ())
-> (forall b. Ptr b -> Int -> IO VkDescriptorPoolResetFlags)
-> (forall b. Ptr b -> Int -> VkDescriptorPoolResetFlags -> IO ())
-> (Ptr VkDescriptorPoolResetFlags
    -> IO VkDescriptorPoolResetFlags)
-> (Ptr VkDescriptorPoolResetFlags
    -> VkDescriptorPoolResetFlags -> IO ())
-> Storable VkDescriptorPoolResetFlags
forall b. Ptr b -> Int -> IO VkDescriptorPoolResetFlags
forall b. Ptr b -> Int -> VkDescriptorPoolResetFlags -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr VkDescriptorPoolResetFlags
-> VkDescriptorPoolResetFlags -> IO ()
$cpoke :: Ptr VkDescriptorPoolResetFlags
-> VkDescriptorPoolResetFlags -> IO ()
peek :: Ptr VkDescriptorPoolResetFlags -> IO VkDescriptorPoolResetFlags
$cpeek :: Ptr VkDescriptorPoolResetFlags -> IO VkDescriptorPoolResetFlags
pokeByteOff :: forall b. Ptr b -> Int -> VkDescriptorPoolResetFlags -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> VkDescriptorPoolResetFlags -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO VkDescriptorPoolResetFlags
$cpeekByteOff :: forall b. Ptr b -> Int -> IO VkDescriptorPoolResetFlags
pokeElemOff :: Ptr VkDescriptorPoolResetFlags
-> Int -> VkDescriptorPoolResetFlags -> IO ()
$cpokeElemOff :: Ptr VkDescriptorPoolResetFlags
-> Int -> VkDescriptorPoolResetFlags -> IO ()
peekElemOff :: Ptr VkDescriptorPoolResetFlags
-> Int -> IO VkDescriptorPoolResetFlags
$cpeekElemOff :: Ptr VkDescriptorPoolResetFlags
-> Int -> IO VkDescriptorPoolResetFlags
alignment :: VkDescriptorPoolResetFlags -> Int
$calignment :: VkDescriptorPoolResetFlags -> Int
sizeOf :: VkDescriptorPoolResetFlags -> Int
$csizeOf :: VkDescriptorPoolResetFlags -> Int
Storable)

instance Show VkDescriptorPoolResetFlags where
    {-# INLINE showsPrec #-}
    showsPrec :: Int -> VkDescriptorPoolResetFlags -> ShowS
showsPrec = (Int -> VkFlags -> ShowS)
-> Int -> VkDescriptorPoolResetFlags -> ShowS
coerce (Int -> VkFlags -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec :: Int -> VkFlags -> ShowS)

instance Read VkDescriptorPoolResetFlags where
    {-# INLINE readsPrec #-}
    readsPrec :: Int -> ReadS VkDescriptorPoolResetFlags
readsPrec = (Int -> ReadS VkFlags) -> Int -> ReadS VkDescriptorPoolResetFlags
coerce (Int -> ReadS VkFlags
forall a. Read a => Int -> ReadS a
readsPrec :: Int -> ReadS VkFlags)

newtype VkDescriptorUpdateTemplateCreateFlags = VkDescriptorUpdateTemplateCreateFlags VkFlags
                                                deriving (VkDescriptorUpdateTemplateCreateFlags
-> VkDescriptorUpdateTemplateCreateFlags -> Bool
(VkDescriptorUpdateTemplateCreateFlags
 -> VkDescriptorUpdateTemplateCreateFlags -> Bool)
-> (VkDescriptorUpdateTemplateCreateFlags
    -> VkDescriptorUpdateTemplateCreateFlags -> Bool)
-> Eq VkDescriptorUpdateTemplateCreateFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VkDescriptorUpdateTemplateCreateFlags
-> VkDescriptorUpdateTemplateCreateFlags -> Bool
$c/= :: VkDescriptorUpdateTemplateCreateFlags
-> VkDescriptorUpdateTemplateCreateFlags -> Bool
== :: VkDescriptorUpdateTemplateCreateFlags
-> VkDescriptorUpdateTemplateCreateFlags -> Bool
$c== :: VkDescriptorUpdateTemplateCreateFlags
-> VkDescriptorUpdateTemplateCreateFlags -> Bool
Eq, Eq VkDescriptorUpdateTemplateCreateFlags
Eq VkDescriptorUpdateTemplateCreateFlags
-> (VkDescriptorUpdateTemplateCreateFlags
    -> VkDescriptorUpdateTemplateCreateFlags -> Ordering)
-> (VkDescriptorUpdateTemplateCreateFlags
    -> VkDescriptorUpdateTemplateCreateFlags -> Bool)
-> (VkDescriptorUpdateTemplateCreateFlags
    -> VkDescriptorUpdateTemplateCreateFlags -> Bool)
-> (VkDescriptorUpdateTemplateCreateFlags
    -> VkDescriptorUpdateTemplateCreateFlags -> Bool)
-> (VkDescriptorUpdateTemplateCreateFlags
    -> VkDescriptorUpdateTemplateCreateFlags -> Bool)
-> (VkDescriptorUpdateTemplateCreateFlags
    -> VkDescriptorUpdateTemplateCreateFlags
    -> VkDescriptorUpdateTemplateCreateFlags)
-> (VkDescriptorUpdateTemplateCreateFlags
    -> VkDescriptorUpdateTemplateCreateFlags
    -> VkDescriptorUpdateTemplateCreateFlags)
-> Ord VkDescriptorUpdateTemplateCreateFlags
VkDescriptorUpdateTemplateCreateFlags
-> VkDescriptorUpdateTemplateCreateFlags -> Bool
VkDescriptorUpdateTemplateCreateFlags
-> VkDescriptorUpdateTemplateCreateFlags -> Ordering
VkDescriptorUpdateTemplateCreateFlags
-> VkDescriptorUpdateTemplateCreateFlags
-> VkDescriptorUpdateTemplateCreateFlags
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: VkDescriptorUpdateTemplateCreateFlags
-> VkDescriptorUpdateTemplateCreateFlags
-> VkDescriptorUpdateTemplateCreateFlags
$cmin :: VkDescriptorUpdateTemplateCreateFlags
-> VkDescriptorUpdateTemplateCreateFlags
-> VkDescriptorUpdateTemplateCreateFlags
max :: VkDescriptorUpdateTemplateCreateFlags
-> VkDescriptorUpdateTemplateCreateFlags
-> VkDescriptorUpdateTemplateCreateFlags
$cmax :: VkDescriptorUpdateTemplateCreateFlags
-> VkDescriptorUpdateTemplateCreateFlags
-> VkDescriptorUpdateTemplateCreateFlags
>= :: VkDescriptorUpdateTemplateCreateFlags
-> VkDescriptorUpdateTemplateCreateFlags -> Bool
$c>= :: VkDescriptorUpdateTemplateCreateFlags
-> VkDescriptorUpdateTemplateCreateFlags -> Bool
> :: VkDescriptorUpdateTemplateCreateFlags
-> VkDescriptorUpdateTemplateCreateFlags -> Bool
$c> :: VkDescriptorUpdateTemplateCreateFlags
-> VkDescriptorUpdateTemplateCreateFlags -> Bool
<= :: VkDescriptorUpdateTemplateCreateFlags
-> VkDescriptorUpdateTemplateCreateFlags -> Bool
$c<= :: VkDescriptorUpdateTemplateCreateFlags
-> VkDescriptorUpdateTemplateCreateFlags -> Bool
< :: VkDescriptorUpdateTemplateCreateFlags
-> VkDescriptorUpdateTemplateCreateFlags -> Bool
$c< :: VkDescriptorUpdateTemplateCreateFlags
-> VkDescriptorUpdateTemplateCreateFlags -> Bool
compare :: VkDescriptorUpdateTemplateCreateFlags
-> VkDescriptorUpdateTemplateCreateFlags -> Ordering
$ccompare :: VkDescriptorUpdateTemplateCreateFlags
-> VkDescriptorUpdateTemplateCreateFlags -> Ordering
Ord, Int -> VkDescriptorUpdateTemplateCreateFlags
VkDescriptorUpdateTemplateCreateFlags -> Int
VkDescriptorUpdateTemplateCreateFlags
-> [VkDescriptorUpdateTemplateCreateFlags]
VkDescriptorUpdateTemplateCreateFlags
-> VkDescriptorUpdateTemplateCreateFlags
VkDescriptorUpdateTemplateCreateFlags
-> VkDescriptorUpdateTemplateCreateFlags
-> [VkDescriptorUpdateTemplateCreateFlags]
VkDescriptorUpdateTemplateCreateFlags
-> VkDescriptorUpdateTemplateCreateFlags
-> VkDescriptorUpdateTemplateCreateFlags
-> [VkDescriptorUpdateTemplateCreateFlags]
(VkDescriptorUpdateTemplateCreateFlags
 -> VkDescriptorUpdateTemplateCreateFlags)
-> (VkDescriptorUpdateTemplateCreateFlags
    -> VkDescriptorUpdateTemplateCreateFlags)
-> (Int -> VkDescriptorUpdateTemplateCreateFlags)
-> (VkDescriptorUpdateTemplateCreateFlags -> Int)
-> (VkDescriptorUpdateTemplateCreateFlags
    -> [VkDescriptorUpdateTemplateCreateFlags])
-> (VkDescriptorUpdateTemplateCreateFlags
    -> VkDescriptorUpdateTemplateCreateFlags
    -> [VkDescriptorUpdateTemplateCreateFlags])
-> (VkDescriptorUpdateTemplateCreateFlags
    -> VkDescriptorUpdateTemplateCreateFlags
    -> [VkDescriptorUpdateTemplateCreateFlags])
-> (VkDescriptorUpdateTemplateCreateFlags
    -> VkDescriptorUpdateTemplateCreateFlags
    -> VkDescriptorUpdateTemplateCreateFlags
    -> [VkDescriptorUpdateTemplateCreateFlags])
-> Enum VkDescriptorUpdateTemplateCreateFlags
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: VkDescriptorUpdateTemplateCreateFlags
-> VkDescriptorUpdateTemplateCreateFlags
-> VkDescriptorUpdateTemplateCreateFlags
-> [VkDescriptorUpdateTemplateCreateFlags]
$cenumFromThenTo :: VkDescriptorUpdateTemplateCreateFlags
-> VkDescriptorUpdateTemplateCreateFlags
-> VkDescriptorUpdateTemplateCreateFlags
-> [VkDescriptorUpdateTemplateCreateFlags]
enumFromTo :: VkDescriptorUpdateTemplateCreateFlags
-> VkDescriptorUpdateTemplateCreateFlags
-> [VkDescriptorUpdateTemplateCreateFlags]
$cenumFromTo :: VkDescriptorUpdateTemplateCreateFlags
-> VkDescriptorUpdateTemplateCreateFlags
-> [VkDescriptorUpdateTemplateCreateFlags]
enumFromThen :: VkDescriptorUpdateTemplateCreateFlags
-> VkDescriptorUpdateTemplateCreateFlags
-> [VkDescriptorUpdateTemplateCreateFlags]
$cenumFromThen :: VkDescriptorUpdateTemplateCreateFlags
-> VkDescriptorUpdateTemplateCreateFlags
-> [VkDescriptorUpdateTemplateCreateFlags]
enumFrom :: VkDescriptorUpdateTemplateCreateFlags
-> [VkDescriptorUpdateTemplateCreateFlags]
$cenumFrom :: VkDescriptorUpdateTemplateCreateFlags
-> [VkDescriptorUpdateTemplateCreateFlags]
fromEnum :: VkDescriptorUpdateTemplateCreateFlags -> Int
$cfromEnum :: VkDescriptorUpdateTemplateCreateFlags -> Int
toEnum :: Int -> VkDescriptorUpdateTemplateCreateFlags
$ctoEnum :: Int -> VkDescriptorUpdateTemplateCreateFlags
pred :: VkDescriptorUpdateTemplateCreateFlags
-> VkDescriptorUpdateTemplateCreateFlags
$cpred :: VkDescriptorUpdateTemplateCreateFlags
-> VkDescriptorUpdateTemplateCreateFlags
succ :: VkDescriptorUpdateTemplateCreateFlags
-> VkDescriptorUpdateTemplateCreateFlags
$csucc :: VkDescriptorUpdateTemplateCreateFlags
-> VkDescriptorUpdateTemplateCreateFlags
Enum, Eq VkDescriptorUpdateTemplateCreateFlags
VkDescriptorUpdateTemplateCreateFlags
Eq VkDescriptorUpdateTemplateCreateFlags
-> (VkDescriptorUpdateTemplateCreateFlags
    -> VkDescriptorUpdateTemplateCreateFlags
    -> VkDescriptorUpdateTemplateCreateFlags)
-> (VkDescriptorUpdateTemplateCreateFlags
    -> VkDescriptorUpdateTemplateCreateFlags
    -> VkDescriptorUpdateTemplateCreateFlags)
-> (VkDescriptorUpdateTemplateCreateFlags
    -> VkDescriptorUpdateTemplateCreateFlags
    -> VkDescriptorUpdateTemplateCreateFlags)
-> (VkDescriptorUpdateTemplateCreateFlags
    -> VkDescriptorUpdateTemplateCreateFlags)
-> (VkDescriptorUpdateTemplateCreateFlags
    -> Int -> VkDescriptorUpdateTemplateCreateFlags)
-> (VkDescriptorUpdateTemplateCreateFlags
    -> Int -> VkDescriptorUpdateTemplateCreateFlags)
-> VkDescriptorUpdateTemplateCreateFlags
-> (Int -> VkDescriptorUpdateTemplateCreateFlags)
-> (VkDescriptorUpdateTemplateCreateFlags
    -> Int -> VkDescriptorUpdateTemplateCreateFlags)
-> (VkDescriptorUpdateTemplateCreateFlags
    -> Int -> VkDescriptorUpdateTemplateCreateFlags)
-> (VkDescriptorUpdateTemplateCreateFlags
    -> Int -> VkDescriptorUpdateTemplateCreateFlags)
-> (VkDescriptorUpdateTemplateCreateFlags -> Int -> Bool)
-> (VkDescriptorUpdateTemplateCreateFlags -> Maybe Int)
-> (VkDescriptorUpdateTemplateCreateFlags -> Int)
-> (VkDescriptorUpdateTemplateCreateFlags -> Bool)
-> (VkDescriptorUpdateTemplateCreateFlags
    -> Int -> VkDescriptorUpdateTemplateCreateFlags)
-> (VkDescriptorUpdateTemplateCreateFlags
    -> Int -> VkDescriptorUpdateTemplateCreateFlags)
-> (VkDescriptorUpdateTemplateCreateFlags
    -> Int -> VkDescriptorUpdateTemplateCreateFlags)
-> (VkDescriptorUpdateTemplateCreateFlags
    -> Int -> VkDescriptorUpdateTemplateCreateFlags)
-> (VkDescriptorUpdateTemplateCreateFlags
    -> Int -> VkDescriptorUpdateTemplateCreateFlags)
-> (VkDescriptorUpdateTemplateCreateFlags
    -> Int -> VkDescriptorUpdateTemplateCreateFlags)
-> (VkDescriptorUpdateTemplateCreateFlags -> Int)
-> Bits VkDescriptorUpdateTemplateCreateFlags
Int -> VkDescriptorUpdateTemplateCreateFlags
VkDescriptorUpdateTemplateCreateFlags -> Bool
VkDescriptorUpdateTemplateCreateFlags -> Int
VkDescriptorUpdateTemplateCreateFlags -> Maybe Int
VkDescriptorUpdateTemplateCreateFlags
-> VkDescriptorUpdateTemplateCreateFlags
VkDescriptorUpdateTemplateCreateFlags -> Int -> Bool
VkDescriptorUpdateTemplateCreateFlags
-> Int -> VkDescriptorUpdateTemplateCreateFlags
VkDescriptorUpdateTemplateCreateFlags
-> VkDescriptorUpdateTemplateCreateFlags
-> VkDescriptorUpdateTemplateCreateFlags
forall a.
Eq a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
popCount :: VkDescriptorUpdateTemplateCreateFlags -> Int
$cpopCount :: VkDescriptorUpdateTemplateCreateFlags -> Int
rotateR :: VkDescriptorUpdateTemplateCreateFlags
-> Int -> VkDescriptorUpdateTemplateCreateFlags
$crotateR :: VkDescriptorUpdateTemplateCreateFlags
-> Int -> VkDescriptorUpdateTemplateCreateFlags
rotateL :: VkDescriptorUpdateTemplateCreateFlags
-> Int -> VkDescriptorUpdateTemplateCreateFlags
$crotateL :: VkDescriptorUpdateTemplateCreateFlags
-> Int -> VkDescriptorUpdateTemplateCreateFlags
unsafeShiftR :: VkDescriptorUpdateTemplateCreateFlags
-> Int -> VkDescriptorUpdateTemplateCreateFlags
$cunsafeShiftR :: VkDescriptorUpdateTemplateCreateFlags
-> Int -> VkDescriptorUpdateTemplateCreateFlags
shiftR :: VkDescriptorUpdateTemplateCreateFlags
-> Int -> VkDescriptorUpdateTemplateCreateFlags
$cshiftR :: VkDescriptorUpdateTemplateCreateFlags
-> Int -> VkDescriptorUpdateTemplateCreateFlags
unsafeShiftL :: VkDescriptorUpdateTemplateCreateFlags
-> Int -> VkDescriptorUpdateTemplateCreateFlags
$cunsafeShiftL :: VkDescriptorUpdateTemplateCreateFlags
-> Int -> VkDescriptorUpdateTemplateCreateFlags
shiftL :: VkDescriptorUpdateTemplateCreateFlags
-> Int -> VkDescriptorUpdateTemplateCreateFlags
$cshiftL :: VkDescriptorUpdateTemplateCreateFlags
-> Int -> VkDescriptorUpdateTemplateCreateFlags
isSigned :: VkDescriptorUpdateTemplateCreateFlags -> Bool
$cisSigned :: VkDescriptorUpdateTemplateCreateFlags -> Bool
bitSize :: VkDescriptorUpdateTemplateCreateFlags -> Int
$cbitSize :: VkDescriptorUpdateTemplateCreateFlags -> Int
bitSizeMaybe :: VkDescriptorUpdateTemplateCreateFlags -> Maybe Int
$cbitSizeMaybe :: VkDescriptorUpdateTemplateCreateFlags -> Maybe Int
testBit :: VkDescriptorUpdateTemplateCreateFlags -> Int -> Bool
$ctestBit :: VkDescriptorUpdateTemplateCreateFlags -> Int -> Bool
complementBit :: VkDescriptorUpdateTemplateCreateFlags
-> Int -> VkDescriptorUpdateTemplateCreateFlags
$ccomplementBit :: VkDescriptorUpdateTemplateCreateFlags
-> Int -> VkDescriptorUpdateTemplateCreateFlags
clearBit :: VkDescriptorUpdateTemplateCreateFlags
-> Int -> VkDescriptorUpdateTemplateCreateFlags
$cclearBit :: VkDescriptorUpdateTemplateCreateFlags
-> Int -> VkDescriptorUpdateTemplateCreateFlags
setBit :: VkDescriptorUpdateTemplateCreateFlags
-> Int -> VkDescriptorUpdateTemplateCreateFlags
$csetBit :: VkDescriptorUpdateTemplateCreateFlags
-> Int -> VkDescriptorUpdateTemplateCreateFlags
bit :: Int -> VkDescriptorUpdateTemplateCreateFlags
$cbit :: Int -> VkDescriptorUpdateTemplateCreateFlags
zeroBits :: VkDescriptorUpdateTemplateCreateFlags
$czeroBits :: VkDescriptorUpdateTemplateCreateFlags
rotate :: VkDescriptorUpdateTemplateCreateFlags
-> Int -> VkDescriptorUpdateTemplateCreateFlags
$crotate :: VkDescriptorUpdateTemplateCreateFlags
-> Int -> VkDescriptorUpdateTemplateCreateFlags
shift :: VkDescriptorUpdateTemplateCreateFlags
-> Int -> VkDescriptorUpdateTemplateCreateFlags
$cshift :: VkDescriptorUpdateTemplateCreateFlags
-> Int -> VkDescriptorUpdateTemplateCreateFlags
complement :: VkDescriptorUpdateTemplateCreateFlags
-> VkDescriptorUpdateTemplateCreateFlags
$ccomplement :: VkDescriptorUpdateTemplateCreateFlags
-> VkDescriptorUpdateTemplateCreateFlags
xor :: VkDescriptorUpdateTemplateCreateFlags
-> VkDescriptorUpdateTemplateCreateFlags
-> VkDescriptorUpdateTemplateCreateFlags
$cxor :: VkDescriptorUpdateTemplateCreateFlags
-> VkDescriptorUpdateTemplateCreateFlags
-> VkDescriptorUpdateTemplateCreateFlags
.|. :: VkDescriptorUpdateTemplateCreateFlags
-> VkDescriptorUpdateTemplateCreateFlags
-> VkDescriptorUpdateTemplateCreateFlags
$c.|. :: VkDescriptorUpdateTemplateCreateFlags
-> VkDescriptorUpdateTemplateCreateFlags
-> VkDescriptorUpdateTemplateCreateFlags
.&. :: VkDescriptorUpdateTemplateCreateFlags
-> VkDescriptorUpdateTemplateCreateFlags
-> VkDescriptorUpdateTemplateCreateFlags
$c.&. :: VkDescriptorUpdateTemplateCreateFlags
-> VkDescriptorUpdateTemplateCreateFlags
-> VkDescriptorUpdateTemplateCreateFlags
Bits, Bits VkDescriptorUpdateTemplateCreateFlags
Bits VkDescriptorUpdateTemplateCreateFlags
-> (VkDescriptorUpdateTemplateCreateFlags -> Int)
-> (VkDescriptorUpdateTemplateCreateFlags -> Int)
-> (VkDescriptorUpdateTemplateCreateFlags -> Int)
-> FiniteBits VkDescriptorUpdateTemplateCreateFlags
VkDescriptorUpdateTemplateCreateFlags -> Int
forall b.
Bits b -> (b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
countTrailingZeros :: VkDescriptorUpdateTemplateCreateFlags -> Int
$ccountTrailingZeros :: VkDescriptorUpdateTemplateCreateFlags -> Int
countLeadingZeros :: VkDescriptorUpdateTemplateCreateFlags -> Int
$ccountLeadingZeros :: VkDescriptorUpdateTemplateCreateFlags -> Int
finiteBitSize :: VkDescriptorUpdateTemplateCreateFlags -> Int
$cfiniteBitSize :: VkDescriptorUpdateTemplateCreateFlags -> Int
FiniteBits, Ptr VkDescriptorUpdateTemplateCreateFlags
-> IO VkDescriptorUpdateTemplateCreateFlags
Ptr VkDescriptorUpdateTemplateCreateFlags
-> Int -> IO VkDescriptorUpdateTemplateCreateFlags
Ptr VkDescriptorUpdateTemplateCreateFlags
-> Int -> VkDescriptorUpdateTemplateCreateFlags -> IO ()
Ptr VkDescriptorUpdateTemplateCreateFlags
-> VkDescriptorUpdateTemplateCreateFlags -> IO ()
VkDescriptorUpdateTemplateCreateFlags -> Int
(VkDescriptorUpdateTemplateCreateFlags -> Int)
-> (VkDescriptorUpdateTemplateCreateFlags -> Int)
-> (Ptr VkDescriptorUpdateTemplateCreateFlags
    -> Int -> IO VkDescriptorUpdateTemplateCreateFlags)
-> (Ptr VkDescriptorUpdateTemplateCreateFlags
    -> Int -> VkDescriptorUpdateTemplateCreateFlags -> IO ())
-> (forall b.
    Ptr b -> Int -> IO VkDescriptorUpdateTemplateCreateFlags)
-> (forall b.
    Ptr b -> Int -> VkDescriptorUpdateTemplateCreateFlags -> IO ())
-> (Ptr VkDescriptorUpdateTemplateCreateFlags
    -> IO VkDescriptorUpdateTemplateCreateFlags)
-> (Ptr VkDescriptorUpdateTemplateCreateFlags
    -> VkDescriptorUpdateTemplateCreateFlags -> IO ())
-> Storable VkDescriptorUpdateTemplateCreateFlags
forall b. Ptr b -> Int -> IO VkDescriptorUpdateTemplateCreateFlags
forall b.
Ptr b -> Int -> VkDescriptorUpdateTemplateCreateFlags -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr VkDescriptorUpdateTemplateCreateFlags
-> VkDescriptorUpdateTemplateCreateFlags -> IO ()
$cpoke :: Ptr VkDescriptorUpdateTemplateCreateFlags
-> VkDescriptorUpdateTemplateCreateFlags -> IO ()
peek :: Ptr VkDescriptorUpdateTemplateCreateFlags
-> IO VkDescriptorUpdateTemplateCreateFlags
$cpeek :: Ptr VkDescriptorUpdateTemplateCreateFlags
-> IO VkDescriptorUpdateTemplateCreateFlags
pokeByteOff :: forall b.
Ptr b -> Int -> VkDescriptorUpdateTemplateCreateFlags -> IO ()
$cpokeByteOff :: forall b.
Ptr b -> Int -> VkDescriptorUpdateTemplateCreateFlags -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO VkDescriptorUpdateTemplateCreateFlags
$cpeekByteOff :: forall b. Ptr b -> Int -> IO VkDescriptorUpdateTemplateCreateFlags
pokeElemOff :: Ptr VkDescriptorUpdateTemplateCreateFlags
-> Int -> VkDescriptorUpdateTemplateCreateFlags -> IO ()
$cpokeElemOff :: Ptr VkDescriptorUpdateTemplateCreateFlags
-> Int -> VkDescriptorUpdateTemplateCreateFlags -> IO ()
peekElemOff :: Ptr VkDescriptorUpdateTemplateCreateFlags
-> Int -> IO VkDescriptorUpdateTemplateCreateFlags
$cpeekElemOff :: Ptr VkDescriptorUpdateTemplateCreateFlags
-> Int -> IO VkDescriptorUpdateTemplateCreateFlags
alignment :: VkDescriptorUpdateTemplateCreateFlags -> Int
$calignment :: VkDescriptorUpdateTemplateCreateFlags -> Int
sizeOf :: VkDescriptorUpdateTemplateCreateFlags -> Int
$csizeOf :: VkDescriptorUpdateTemplateCreateFlags -> Int
Storable)

instance Show VkDescriptorUpdateTemplateCreateFlags where
    {-# INLINE showsPrec #-}
    showsPrec :: Int -> VkDescriptorUpdateTemplateCreateFlags -> ShowS
showsPrec = (Int -> VkFlags -> ShowS)
-> Int -> VkDescriptorUpdateTemplateCreateFlags -> ShowS
coerce (Int -> VkFlags -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec :: Int -> VkFlags -> ShowS)

instance Read VkDescriptorUpdateTemplateCreateFlags where
    {-# INLINE readsPrec #-}
    readsPrec :: Int -> ReadS VkDescriptorUpdateTemplateCreateFlags
readsPrec = (Int -> ReadS VkFlags)
-> Int -> ReadS VkDescriptorUpdateTemplateCreateFlags
coerce (Int -> ReadS VkFlags
forall a. Read a => Int -> ReadS a
readsPrec :: Int -> ReadS VkFlags)

newtype VkDescriptorUpdateTemplateCreateFlagsKHR = VkDescriptorUpdateTemplateCreateFlagsKHR VkFlags
                                                   deriving (VkDescriptorUpdateTemplateCreateFlagsKHR
-> VkDescriptorUpdateTemplateCreateFlagsKHR -> Bool
(VkDescriptorUpdateTemplateCreateFlagsKHR
 -> VkDescriptorUpdateTemplateCreateFlagsKHR -> Bool)
-> (VkDescriptorUpdateTemplateCreateFlagsKHR
    -> VkDescriptorUpdateTemplateCreateFlagsKHR -> Bool)
-> Eq VkDescriptorUpdateTemplateCreateFlagsKHR
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VkDescriptorUpdateTemplateCreateFlagsKHR
-> VkDescriptorUpdateTemplateCreateFlagsKHR -> Bool
$c/= :: VkDescriptorUpdateTemplateCreateFlagsKHR
-> VkDescriptorUpdateTemplateCreateFlagsKHR -> Bool
== :: VkDescriptorUpdateTemplateCreateFlagsKHR
-> VkDescriptorUpdateTemplateCreateFlagsKHR -> Bool
$c== :: VkDescriptorUpdateTemplateCreateFlagsKHR
-> VkDescriptorUpdateTemplateCreateFlagsKHR -> Bool
Eq, Eq VkDescriptorUpdateTemplateCreateFlagsKHR
Eq VkDescriptorUpdateTemplateCreateFlagsKHR
-> (VkDescriptorUpdateTemplateCreateFlagsKHR
    -> VkDescriptorUpdateTemplateCreateFlagsKHR -> Ordering)
-> (VkDescriptorUpdateTemplateCreateFlagsKHR
    -> VkDescriptorUpdateTemplateCreateFlagsKHR -> Bool)
-> (VkDescriptorUpdateTemplateCreateFlagsKHR
    -> VkDescriptorUpdateTemplateCreateFlagsKHR -> Bool)
-> (VkDescriptorUpdateTemplateCreateFlagsKHR
    -> VkDescriptorUpdateTemplateCreateFlagsKHR -> Bool)
-> (VkDescriptorUpdateTemplateCreateFlagsKHR
    -> VkDescriptorUpdateTemplateCreateFlagsKHR -> Bool)
-> (VkDescriptorUpdateTemplateCreateFlagsKHR
    -> VkDescriptorUpdateTemplateCreateFlagsKHR
    -> VkDescriptorUpdateTemplateCreateFlagsKHR)
-> (VkDescriptorUpdateTemplateCreateFlagsKHR
    -> VkDescriptorUpdateTemplateCreateFlagsKHR
    -> VkDescriptorUpdateTemplateCreateFlagsKHR)
-> Ord VkDescriptorUpdateTemplateCreateFlagsKHR
VkDescriptorUpdateTemplateCreateFlagsKHR
-> VkDescriptorUpdateTemplateCreateFlagsKHR -> Bool
VkDescriptorUpdateTemplateCreateFlagsKHR
-> VkDescriptorUpdateTemplateCreateFlagsKHR -> Ordering
VkDescriptorUpdateTemplateCreateFlagsKHR
-> VkDescriptorUpdateTemplateCreateFlagsKHR
-> VkDescriptorUpdateTemplateCreateFlagsKHR
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: VkDescriptorUpdateTemplateCreateFlagsKHR
-> VkDescriptorUpdateTemplateCreateFlagsKHR
-> VkDescriptorUpdateTemplateCreateFlagsKHR
$cmin :: VkDescriptorUpdateTemplateCreateFlagsKHR
-> VkDescriptorUpdateTemplateCreateFlagsKHR
-> VkDescriptorUpdateTemplateCreateFlagsKHR
max :: VkDescriptorUpdateTemplateCreateFlagsKHR
-> VkDescriptorUpdateTemplateCreateFlagsKHR
-> VkDescriptorUpdateTemplateCreateFlagsKHR
$cmax :: VkDescriptorUpdateTemplateCreateFlagsKHR
-> VkDescriptorUpdateTemplateCreateFlagsKHR
-> VkDescriptorUpdateTemplateCreateFlagsKHR
>= :: VkDescriptorUpdateTemplateCreateFlagsKHR
-> VkDescriptorUpdateTemplateCreateFlagsKHR -> Bool
$c>= :: VkDescriptorUpdateTemplateCreateFlagsKHR
-> VkDescriptorUpdateTemplateCreateFlagsKHR -> Bool
> :: VkDescriptorUpdateTemplateCreateFlagsKHR
-> VkDescriptorUpdateTemplateCreateFlagsKHR -> Bool
$c> :: VkDescriptorUpdateTemplateCreateFlagsKHR
-> VkDescriptorUpdateTemplateCreateFlagsKHR -> Bool
<= :: VkDescriptorUpdateTemplateCreateFlagsKHR
-> VkDescriptorUpdateTemplateCreateFlagsKHR -> Bool
$c<= :: VkDescriptorUpdateTemplateCreateFlagsKHR
-> VkDescriptorUpdateTemplateCreateFlagsKHR -> Bool
< :: VkDescriptorUpdateTemplateCreateFlagsKHR
-> VkDescriptorUpdateTemplateCreateFlagsKHR -> Bool
$c< :: VkDescriptorUpdateTemplateCreateFlagsKHR
-> VkDescriptorUpdateTemplateCreateFlagsKHR -> Bool
compare :: VkDescriptorUpdateTemplateCreateFlagsKHR
-> VkDescriptorUpdateTemplateCreateFlagsKHR -> Ordering
$ccompare :: VkDescriptorUpdateTemplateCreateFlagsKHR
-> VkDescriptorUpdateTemplateCreateFlagsKHR -> Ordering
Ord, Int -> VkDescriptorUpdateTemplateCreateFlagsKHR
VkDescriptorUpdateTemplateCreateFlagsKHR -> Int
VkDescriptorUpdateTemplateCreateFlagsKHR
-> [VkDescriptorUpdateTemplateCreateFlagsKHR]
VkDescriptorUpdateTemplateCreateFlagsKHR
-> VkDescriptorUpdateTemplateCreateFlagsKHR
VkDescriptorUpdateTemplateCreateFlagsKHR
-> VkDescriptorUpdateTemplateCreateFlagsKHR
-> [VkDescriptorUpdateTemplateCreateFlagsKHR]
VkDescriptorUpdateTemplateCreateFlagsKHR
-> VkDescriptorUpdateTemplateCreateFlagsKHR
-> VkDescriptorUpdateTemplateCreateFlagsKHR
-> [VkDescriptorUpdateTemplateCreateFlagsKHR]
(VkDescriptorUpdateTemplateCreateFlagsKHR
 -> VkDescriptorUpdateTemplateCreateFlagsKHR)
-> (VkDescriptorUpdateTemplateCreateFlagsKHR
    -> VkDescriptorUpdateTemplateCreateFlagsKHR)
-> (Int -> VkDescriptorUpdateTemplateCreateFlagsKHR)
-> (VkDescriptorUpdateTemplateCreateFlagsKHR -> Int)
-> (VkDescriptorUpdateTemplateCreateFlagsKHR
    -> [VkDescriptorUpdateTemplateCreateFlagsKHR])
-> (VkDescriptorUpdateTemplateCreateFlagsKHR
    -> VkDescriptorUpdateTemplateCreateFlagsKHR
    -> [VkDescriptorUpdateTemplateCreateFlagsKHR])
-> (VkDescriptorUpdateTemplateCreateFlagsKHR
    -> VkDescriptorUpdateTemplateCreateFlagsKHR
    -> [VkDescriptorUpdateTemplateCreateFlagsKHR])
-> (VkDescriptorUpdateTemplateCreateFlagsKHR
    -> VkDescriptorUpdateTemplateCreateFlagsKHR
    -> VkDescriptorUpdateTemplateCreateFlagsKHR
    -> [VkDescriptorUpdateTemplateCreateFlagsKHR])
-> Enum VkDescriptorUpdateTemplateCreateFlagsKHR
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: VkDescriptorUpdateTemplateCreateFlagsKHR
-> VkDescriptorUpdateTemplateCreateFlagsKHR
-> VkDescriptorUpdateTemplateCreateFlagsKHR
-> [VkDescriptorUpdateTemplateCreateFlagsKHR]
$cenumFromThenTo :: VkDescriptorUpdateTemplateCreateFlagsKHR
-> VkDescriptorUpdateTemplateCreateFlagsKHR
-> VkDescriptorUpdateTemplateCreateFlagsKHR
-> [VkDescriptorUpdateTemplateCreateFlagsKHR]
enumFromTo :: VkDescriptorUpdateTemplateCreateFlagsKHR
-> VkDescriptorUpdateTemplateCreateFlagsKHR
-> [VkDescriptorUpdateTemplateCreateFlagsKHR]
$cenumFromTo :: VkDescriptorUpdateTemplateCreateFlagsKHR
-> VkDescriptorUpdateTemplateCreateFlagsKHR
-> [VkDescriptorUpdateTemplateCreateFlagsKHR]
enumFromThen :: VkDescriptorUpdateTemplateCreateFlagsKHR
-> VkDescriptorUpdateTemplateCreateFlagsKHR
-> [VkDescriptorUpdateTemplateCreateFlagsKHR]
$cenumFromThen :: VkDescriptorUpdateTemplateCreateFlagsKHR
-> VkDescriptorUpdateTemplateCreateFlagsKHR
-> [VkDescriptorUpdateTemplateCreateFlagsKHR]
enumFrom :: VkDescriptorUpdateTemplateCreateFlagsKHR
-> [VkDescriptorUpdateTemplateCreateFlagsKHR]
$cenumFrom :: VkDescriptorUpdateTemplateCreateFlagsKHR
-> [VkDescriptorUpdateTemplateCreateFlagsKHR]
fromEnum :: VkDescriptorUpdateTemplateCreateFlagsKHR -> Int
$cfromEnum :: VkDescriptorUpdateTemplateCreateFlagsKHR -> Int
toEnum :: Int -> VkDescriptorUpdateTemplateCreateFlagsKHR
$ctoEnum :: Int -> VkDescriptorUpdateTemplateCreateFlagsKHR
pred :: VkDescriptorUpdateTemplateCreateFlagsKHR
-> VkDescriptorUpdateTemplateCreateFlagsKHR
$cpred :: VkDescriptorUpdateTemplateCreateFlagsKHR
-> VkDescriptorUpdateTemplateCreateFlagsKHR
succ :: VkDescriptorUpdateTemplateCreateFlagsKHR
-> VkDescriptorUpdateTemplateCreateFlagsKHR
$csucc :: VkDescriptorUpdateTemplateCreateFlagsKHR
-> VkDescriptorUpdateTemplateCreateFlagsKHR
Enum, Eq VkDescriptorUpdateTemplateCreateFlagsKHR
VkDescriptorUpdateTemplateCreateFlagsKHR
Eq VkDescriptorUpdateTemplateCreateFlagsKHR
-> (VkDescriptorUpdateTemplateCreateFlagsKHR
    -> VkDescriptorUpdateTemplateCreateFlagsKHR
    -> VkDescriptorUpdateTemplateCreateFlagsKHR)
-> (VkDescriptorUpdateTemplateCreateFlagsKHR
    -> VkDescriptorUpdateTemplateCreateFlagsKHR
    -> VkDescriptorUpdateTemplateCreateFlagsKHR)
-> (VkDescriptorUpdateTemplateCreateFlagsKHR
    -> VkDescriptorUpdateTemplateCreateFlagsKHR
    -> VkDescriptorUpdateTemplateCreateFlagsKHR)
-> (VkDescriptorUpdateTemplateCreateFlagsKHR
    -> VkDescriptorUpdateTemplateCreateFlagsKHR)
-> (VkDescriptorUpdateTemplateCreateFlagsKHR
    -> Int -> VkDescriptorUpdateTemplateCreateFlagsKHR)
-> (VkDescriptorUpdateTemplateCreateFlagsKHR
    -> Int -> VkDescriptorUpdateTemplateCreateFlagsKHR)
-> VkDescriptorUpdateTemplateCreateFlagsKHR
-> (Int -> VkDescriptorUpdateTemplateCreateFlagsKHR)
-> (VkDescriptorUpdateTemplateCreateFlagsKHR
    -> Int -> VkDescriptorUpdateTemplateCreateFlagsKHR)
-> (VkDescriptorUpdateTemplateCreateFlagsKHR
    -> Int -> VkDescriptorUpdateTemplateCreateFlagsKHR)
-> (VkDescriptorUpdateTemplateCreateFlagsKHR
    -> Int -> VkDescriptorUpdateTemplateCreateFlagsKHR)
-> (VkDescriptorUpdateTemplateCreateFlagsKHR -> Int -> Bool)
-> (VkDescriptorUpdateTemplateCreateFlagsKHR -> Maybe Int)
-> (VkDescriptorUpdateTemplateCreateFlagsKHR -> Int)
-> (VkDescriptorUpdateTemplateCreateFlagsKHR -> Bool)
-> (VkDescriptorUpdateTemplateCreateFlagsKHR
    -> Int -> VkDescriptorUpdateTemplateCreateFlagsKHR)
-> (VkDescriptorUpdateTemplateCreateFlagsKHR
    -> Int -> VkDescriptorUpdateTemplateCreateFlagsKHR)
-> (VkDescriptorUpdateTemplateCreateFlagsKHR
    -> Int -> VkDescriptorUpdateTemplateCreateFlagsKHR)
-> (VkDescriptorUpdateTemplateCreateFlagsKHR
    -> Int -> VkDescriptorUpdateTemplateCreateFlagsKHR)
-> (VkDescriptorUpdateTemplateCreateFlagsKHR
    -> Int -> VkDescriptorUpdateTemplateCreateFlagsKHR)
-> (VkDescriptorUpdateTemplateCreateFlagsKHR
    -> Int -> VkDescriptorUpdateTemplateCreateFlagsKHR)
-> (VkDescriptorUpdateTemplateCreateFlagsKHR -> Int)
-> Bits VkDescriptorUpdateTemplateCreateFlagsKHR
Int -> VkDescriptorUpdateTemplateCreateFlagsKHR
VkDescriptorUpdateTemplateCreateFlagsKHR -> Bool
VkDescriptorUpdateTemplateCreateFlagsKHR -> Int
VkDescriptorUpdateTemplateCreateFlagsKHR -> Maybe Int
VkDescriptorUpdateTemplateCreateFlagsKHR
-> VkDescriptorUpdateTemplateCreateFlagsKHR
VkDescriptorUpdateTemplateCreateFlagsKHR -> Int -> Bool
VkDescriptorUpdateTemplateCreateFlagsKHR
-> Int -> VkDescriptorUpdateTemplateCreateFlagsKHR
VkDescriptorUpdateTemplateCreateFlagsKHR
-> VkDescriptorUpdateTemplateCreateFlagsKHR
-> VkDescriptorUpdateTemplateCreateFlagsKHR
forall a.
Eq a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
popCount :: VkDescriptorUpdateTemplateCreateFlagsKHR -> Int
$cpopCount :: VkDescriptorUpdateTemplateCreateFlagsKHR -> Int
rotateR :: VkDescriptorUpdateTemplateCreateFlagsKHR
-> Int -> VkDescriptorUpdateTemplateCreateFlagsKHR
$crotateR :: VkDescriptorUpdateTemplateCreateFlagsKHR
-> Int -> VkDescriptorUpdateTemplateCreateFlagsKHR
rotateL :: VkDescriptorUpdateTemplateCreateFlagsKHR
-> Int -> VkDescriptorUpdateTemplateCreateFlagsKHR
$crotateL :: VkDescriptorUpdateTemplateCreateFlagsKHR
-> Int -> VkDescriptorUpdateTemplateCreateFlagsKHR
unsafeShiftR :: VkDescriptorUpdateTemplateCreateFlagsKHR
-> Int -> VkDescriptorUpdateTemplateCreateFlagsKHR
$cunsafeShiftR :: VkDescriptorUpdateTemplateCreateFlagsKHR
-> Int -> VkDescriptorUpdateTemplateCreateFlagsKHR
shiftR :: VkDescriptorUpdateTemplateCreateFlagsKHR
-> Int -> VkDescriptorUpdateTemplateCreateFlagsKHR
$cshiftR :: VkDescriptorUpdateTemplateCreateFlagsKHR
-> Int -> VkDescriptorUpdateTemplateCreateFlagsKHR
unsafeShiftL :: VkDescriptorUpdateTemplateCreateFlagsKHR
-> Int -> VkDescriptorUpdateTemplateCreateFlagsKHR
$cunsafeShiftL :: VkDescriptorUpdateTemplateCreateFlagsKHR
-> Int -> VkDescriptorUpdateTemplateCreateFlagsKHR
shiftL :: VkDescriptorUpdateTemplateCreateFlagsKHR
-> Int -> VkDescriptorUpdateTemplateCreateFlagsKHR
$cshiftL :: VkDescriptorUpdateTemplateCreateFlagsKHR
-> Int -> VkDescriptorUpdateTemplateCreateFlagsKHR
isSigned :: VkDescriptorUpdateTemplateCreateFlagsKHR -> Bool
$cisSigned :: VkDescriptorUpdateTemplateCreateFlagsKHR -> Bool
bitSize :: VkDescriptorUpdateTemplateCreateFlagsKHR -> Int
$cbitSize :: VkDescriptorUpdateTemplateCreateFlagsKHR -> Int
bitSizeMaybe :: VkDescriptorUpdateTemplateCreateFlagsKHR -> Maybe Int
$cbitSizeMaybe :: VkDescriptorUpdateTemplateCreateFlagsKHR -> Maybe Int
testBit :: VkDescriptorUpdateTemplateCreateFlagsKHR -> Int -> Bool
$ctestBit :: VkDescriptorUpdateTemplateCreateFlagsKHR -> Int -> Bool
complementBit :: VkDescriptorUpdateTemplateCreateFlagsKHR
-> Int -> VkDescriptorUpdateTemplateCreateFlagsKHR
$ccomplementBit :: VkDescriptorUpdateTemplateCreateFlagsKHR
-> Int -> VkDescriptorUpdateTemplateCreateFlagsKHR
clearBit :: VkDescriptorUpdateTemplateCreateFlagsKHR
-> Int -> VkDescriptorUpdateTemplateCreateFlagsKHR
$cclearBit :: VkDescriptorUpdateTemplateCreateFlagsKHR
-> Int -> VkDescriptorUpdateTemplateCreateFlagsKHR
setBit :: VkDescriptorUpdateTemplateCreateFlagsKHR
-> Int -> VkDescriptorUpdateTemplateCreateFlagsKHR
$csetBit :: VkDescriptorUpdateTemplateCreateFlagsKHR
-> Int -> VkDescriptorUpdateTemplateCreateFlagsKHR
bit :: Int -> VkDescriptorUpdateTemplateCreateFlagsKHR
$cbit :: Int -> VkDescriptorUpdateTemplateCreateFlagsKHR
zeroBits :: VkDescriptorUpdateTemplateCreateFlagsKHR
$czeroBits :: VkDescriptorUpdateTemplateCreateFlagsKHR
rotate :: VkDescriptorUpdateTemplateCreateFlagsKHR
-> Int -> VkDescriptorUpdateTemplateCreateFlagsKHR
$crotate :: VkDescriptorUpdateTemplateCreateFlagsKHR
-> Int -> VkDescriptorUpdateTemplateCreateFlagsKHR
shift :: VkDescriptorUpdateTemplateCreateFlagsKHR
-> Int -> VkDescriptorUpdateTemplateCreateFlagsKHR
$cshift :: VkDescriptorUpdateTemplateCreateFlagsKHR
-> Int -> VkDescriptorUpdateTemplateCreateFlagsKHR
complement :: VkDescriptorUpdateTemplateCreateFlagsKHR
-> VkDescriptorUpdateTemplateCreateFlagsKHR
$ccomplement :: VkDescriptorUpdateTemplateCreateFlagsKHR
-> VkDescriptorUpdateTemplateCreateFlagsKHR
xor :: VkDescriptorUpdateTemplateCreateFlagsKHR
-> VkDescriptorUpdateTemplateCreateFlagsKHR
-> VkDescriptorUpdateTemplateCreateFlagsKHR
$cxor :: VkDescriptorUpdateTemplateCreateFlagsKHR
-> VkDescriptorUpdateTemplateCreateFlagsKHR
-> VkDescriptorUpdateTemplateCreateFlagsKHR
.|. :: VkDescriptorUpdateTemplateCreateFlagsKHR
-> VkDescriptorUpdateTemplateCreateFlagsKHR
-> VkDescriptorUpdateTemplateCreateFlagsKHR
$c.|. :: VkDescriptorUpdateTemplateCreateFlagsKHR
-> VkDescriptorUpdateTemplateCreateFlagsKHR
-> VkDescriptorUpdateTemplateCreateFlagsKHR
.&. :: VkDescriptorUpdateTemplateCreateFlagsKHR
-> VkDescriptorUpdateTemplateCreateFlagsKHR
-> VkDescriptorUpdateTemplateCreateFlagsKHR
$c.&. :: VkDescriptorUpdateTemplateCreateFlagsKHR
-> VkDescriptorUpdateTemplateCreateFlagsKHR
-> VkDescriptorUpdateTemplateCreateFlagsKHR
Bits, Bits VkDescriptorUpdateTemplateCreateFlagsKHR
Bits VkDescriptorUpdateTemplateCreateFlagsKHR
-> (VkDescriptorUpdateTemplateCreateFlagsKHR -> Int)
-> (VkDescriptorUpdateTemplateCreateFlagsKHR -> Int)
-> (VkDescriptorUpdateTemplateCreateFlagsKHR -> Int)
-> FiniteBits VkDescriptorUpdateTemplateCreateFlagsKHR
VkDescriptorUpdateTemplateCreateFlagsKHR -> Int
forall b.
Bits b -> (b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
countTrailingZeros :: VkDescriptorUpdateTemplateCreateFlagsKHR -> Int
$ccountTrailingZeros :: VkDescriptorUpdateTemplateCreateFlagsKHR -> Int
countLeadingZeros :: VkDescriptorUpdateTemplateCreateFlagsKHR -> Int
$ccountLeadingZeros :: VkDescriptorUpdateTemplateCreateFlagsKHR -> Int
finiteBitSize :: VkDescriptorUpdateTemplateCreateFlagsKHR -> Int
$cfiniteBitSize :: VkDescriptorUpdateTemplateCreateFlagsKHR -> Int
FiniteBits,
                                                             Ptr VkDescriptorUpdateTemplateCreateFlagsKHR
-> IO VkDescriptorUpdateTemplateCreateFlagsKHR
Ptr VkDescriptorUpdateTemplateCreateFlagsKHR
-> Int -> IO VkDescriptorUpdateTemplateCreateFlagsKHR
Ptr VkDescriptorUpdateTemplateCreateFlagsKHR
-> Int -> VkDescriptorUpdateTemplateCreateFlagsKHR -> IO ()
Ptr VkDescriptorUpdateTemplateCreateFlagsKHR
-> VkDescriptorUpdateTemplateCreateFlagsKHR -> IO ()
VkDescriptorUpdateTemplateCreateFlagsKHR -> Int
(VkDescriptorUpdateTemplateCreateFlagsKHR -> Int)
-> (VkDescriptorUpdateTemplateCreateFlagsKHR -> Int)
-> (Ptr VkDescriptorUpdateTemplateCreateFlagsKHR
    -> Int -> IO VkDescriptorUpdateTemplateCreateFlagsKHR)
-> (Ptr VkDescriptorUpdateTemplateCreateFlagsKHR
    -> Int -> VkDescriptorUpdateTemplateCreateFlagsKHR -> IO ())
-> (forall b.
    Ptr b -> Int -> IO VkDescriptorUpdateTemplateCreateFlagsKHR)
-> (forall b.
    Ptr b -> Int -> VkDescriptorUpdateTemplateCreateFlagsKHR -> IO ())
-> (Ptr VkDescriptorUpdateTemplateCreateFlagsKHR
    -> IO VkDescriptorUpdateTemplateCreateFlagsKHR)
-> (Ptr VkDescriptorUpdateTemplateCreateFlagsKHR
    -> VkDescriptorUpdateTemplateCreateFlagsKHR -> IO ())
-> Storable VkDescriptorUpdateTemplateCreateFlagsKHR
forall b.
Ptr b -> Int -> IO VkDescriptorUpdateTemplateCreateFlagsKHR
forall b.
Ptr b -> Int -> VkDescriptorUpdateTemplateCreateFlagsKHR -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr VkDescriptorUpdateTemplateCreateFlagsKHR
-> VkDescriptorUpdateTemplateCreateFlagsKHR -> IO ()
$cpoke :: Ptr VkDescriptorUpdateTemplateCreateFlagsKHR
-> VkDescriptorUpdateTemplateCreateFlagsKHR -> IO ()
peek :: Ptr VkDescriptorUpdateTemplateCreateFlagsKHR
-> IO VkDescriptorUpdateTemplateCreateFlagsKHR
$cpeek :: Ptr VkDescriptorUpdateTemplateCreateFlagsKHR
-> IO VkDescriptorUpdateTemplateCreateFlagsKHR
pokeByteOff :: forall b.
Ptr b -> Int -> VkDescriptorUpdateTemplateCreateFlagsKHR -> IO ()
$cpokeByteOff :: forall b.
Ptr b -> Int -> VkDescriptorUpdateTemplateCreateFlagsKHR -> IO ()
peekByteOff :: forall b.
Ptr b -> Int -> IO VkDescriptorUpdateTemplateCreateFlagsKHR
$cpeekByteOff :: forall b.
Ptr b -> Int -> IO VkDescriptorUpdateTemplateCreateFlagsKHR
pokeElemOff :: Ptr VkDescriptorUpdateTemplateCreateFlagsKHR
-> Int -> VkDescriptorUpdateTemplateCreateFlagsKHR -> IO ()
$cpokeElemOff :: Ptr VkDescriptorUpdateTemplateCreateFlagsKHR
-> Int -> VkDescriptorUpdateTemplateCreateFlagsKHR -> IO ()
peekElemOff :: Ptr VkDescriptorUpdateTemplateCreateFlagsKHR
-> Int -> IO VkDescriptorUpdateTemplateCreateFlagsKHR
$cpeekElemOff :: Ptr VkDescriptorUpdateTemplateCreateFlagsKHR
-> Int -> IO VkDescriptorUpdateTemplateCreateFlagsKHR
alignment :: VkDescriptorUpdateTemplateCreateFlagsKHR -> Int
$calignment :: VkDescriptorUpdateTemplateCreateFlagsKHR -> Int
sizeOf :: VkDescriptorUpdateTemplateCreateFlagsKHR -> Int
$csizeOf :: VkDescriptorUpdateTemplateCreateFlagsKHR -> Int
Storable)

instance Show VkDescriptorUpdateTemplateCreateFlagsKHR where
    {-# INLINE showsPrec #-}
    showsPrec :: Int -> VkDescriptorUpdateTemplateCreateFlagsKHR -> ShowS
showsPrec = (Int -> VkFlags -> ShowS)
-> Int -> VkDescriptorUpdateTemplateCreateFlagsKHR -> ShowS
coerce (Int -> VkFlags -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec :: Int -> VkFlags -> ShowS)

instance Read VkDescriptorUpdateTemplateCreateFlagsKHR where
    {-# INLINE readsPrec #-}
    readsPrec :: Int -> ReadS VkDescriptorUpdateTemplateCreateFlagsKHR
readsPrec = (Int -> ReadS VkFlags)
-> Int -> ReadS VkDescriptorUpdateTemplateCreateFlagsKHR
coerce (Int -> ReadS VkFlags
forall a. Read a => Int -> ReadS a
readsPrec :: Int -> ReadS VkFlags)

newtype VkDeviceCreateFlags = VkDeviceCreateFlags VkFlags
                              deriving (VkDeviceCreateFlags -> VkDeviceCreateFlags -> Bool
(VkDeviceCreateFlags -> VkDeviceCreateFlags -> Bool)
-> (VkDeviceCreateFlags -> VkDeviceCreateFlags -> Bool)
-> Eq VkDeviceCreateFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VkDeviceCreateFlags -> VkDeviceCreateFlags -> Bool
$c/= :: VkDeviceCreateFlags -> VkDeviceCreateFlags -> Bool
== :: VkDeviceCreateFlags -> VkDeviceCreateFlags -> Bool
$c== :: VkDeviceCreateFlags -> VkDeviceCreateFlags -> Bool
Eq, Eq VkDeviceCreateFlags
Eq VkDeviceCreateFlags
-> (VkDeviceCreateFlags -> VkDeviceCreateFlags -> Ordering)
-> (VkDeviceCreateFlags -> VkDeviceCreateFlags -> Bool)
-> (VkDeviceCreateFlags -> VkDeviceCreateFlags -> Bool)
-> (VkDeviceCreateFlags -> VkDeviceCreateFlags -> Bool)
-> (VkDeviceCreateFlags -> VkDeviceCreateFlags -> Bool)
-> (VkDeviceCreateFlags
    -> VkDeviceCreateFlags -> VkDeviceCreateFlags)
-> (VkDeviceCreateFlags
    -> VkDeviceCreateFlags -> VkDeviceCreateFlags)
-> Ord VkDeviceCreateFlags
VkDeviceCreateFlags -> VkDeviceCreateFlags -> Bool
VkDeviceCreateFlags -> VkDeviceCreateFlags -> Ordering
VkDeviceCreateFlags -> VkDeviceCreateFlags -> VkDeviceCreateFlags
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: VkDeviceCreateFlags -> VkDeviceCreateFlags -> VkDeviceCreateFlags
$cmin :: VkDeviceCreateFlags -> VkDeviceCreateFlags -> VkDeviceCreateFlags
max :: VkDeviceCreateFlags -> VkDeviceCreateFlags -> VkDeviceCreateFlags
$cmax :: VkDeviceCreateFlags -> VkDeviceCreateFlags -> VkDeviceCreateFlags
>= :: VkDeviceCreateFlags -> VkDeviceCreateFlags -> Bool
$c>= :: VkDeviceCreateFlags -> VkDeviceCreateFlags -> Bool
> :: VkDeviceCreateFlags -> VkDeviceCreateFlags -> Bool
$c> :: VkDeviceCreateFlags -> VkDeviceCreateFlags -> Bool
<= :: VkDeviceCreateFlags -> VkDeviceCreateFlags -> Bool
$c<= :: VkDeviceCreateFlags -> VkDeviceCreateFlags -> Bool
< :: VkDeviceCreateFlags -> VkDeviceCreateFlags -> Bool
$c< :: VkDeviceCreateFlags -> VkDeviceCreateFlags -> Bool
compare :: VkDeviceCreateFlags -> VkDeviceCreateFlags -> Ordering
$ccompare :: VkDeviceCreateFlags -> VkDeviceCreateFlags -> Ordering
Ord, Int -> VkDeviceCreateFlags
VkDeviceCreateFlags -> Int
VkDeviceCreateFlags -> [VkDeviceCreateFlags]
VkDeviceCreateFlags -> VkDeviceCreateFlags
VkDeviceCreateFlags -> VkDeviceCreateFlags -> [VkDeviceCreateFlags]
VkDeviceCreateFlags
-> VkDeviceCreateFlags
-> VkDeviceCreateFlags
-> [VkDeviceCreateFlags]
(VkDeviceCreateFlags -> VkDeviceCreateFlags)
-> (VkDeviceCreateFlags -> VkDeviceCreateFlags)
-> (Int -> VkDeviceCreateFlags)
-> (VkDeviceCreateFlags -> Int)
-> (VkDeviceCreateFlags -> [VkDeviceCreateFlags])
-> (VkDeviceCreateFlags
    -> VkDeviceCreateFlags -> [VkDeviceCreateFlags])
-> (VkDeviceCreateFlags
    -> VkDeviceCreateFlags -> [VkDeviceCreateFlags])
-> (VkDeviceCreateFlags
    -> VkDeviceCreateFlags
    -> VkDeviceCreateFlags
    -> [VkDeviceCreateFlags])
-> Enum VkDeviceCreateFlags
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: VkDeviceCreateFlags
-> VkDeviceCreateFlags
-> VkDeviceCreateFlags
-> [VkDeviceCreateFlags]
$cenumFromThenTo :: VkDeviceCreateFlags
-> VkDeviceCreateFlags
-> VkDeviceCreateFlags
-> [VkDeviceCreateFlags]
enumFromTo :: VkDeviceCreateFlags -> VkDeviceCreateFlags -> [VkDeviceCreateFlags]
$cenumFromTo :: VkDeviceCreateFlags -> VkDeviceCreateFlags -> [VkDeviceCreateFlags]
enumFromThen :: VkDeviceCreateFlags -> VkDeviceCreateFlags -> [VkDeviceCreateFlags]
$cenumFromThen :: VkDeviceCreateFlags -> VkDeviceCreateFlags -> [VkDeviceCreateFlags]
enumFrom :: VkDeviceCreateFlags -> [VkDeviceCreateFlags]
$cenumFrom :: VkDeviceCreateFlags -> [VkDeviceCreateFlags]
fromEnum :: VkDeviceCreateFlags -> Int
$cfromEnum :: VkDeviceCreateFlags -> Int
toEnum :: Int -> VkDeviceCreateFlags
$ctoEnum :: Int -> VkDeviceCreateFlags
pred :: VkDeviceCreateFlags -> VkDeviceCreateFlags
$cpred :: VkDeviceCreateFlags -> VkDeviceCreateFlags
succ :: VkDeviceCreateFlags -> VkDeviceCreateFlags
$csucc :: VkDeviceCreateFlags -> VkDeviceCreateFlags
Enum, Eq VkDeviceCreateFlags
VkDeviceCreateFlags
Eq VkDeviceCreateFlags
-> (VkDeviceCreateFlags
    -> VkDeviceCreateFlags -> VkDeviceCreateFlags)
-> (VkDeviceCreateFlags
    -> VkDeviceCreateFlags -> VkDeviceCreateFlags)
-> (VkDeviceCreateFlags
    -> VkDeviceCreateFlags -> VkDeviceCreateFlags)
-> (VkDeviceCreateFlags -> VkDeviceCreateFlags)
-> (VkDeviceCreateFlags -> Int -> VkDeviceCreateFlags)
-> (VkDeviceCreateFlags -> Int -> VkDeviceCreateFlags)
-> VkDeviceCreateFlags
-> (Int -> VkDeviceCreateFlags)
-> (VkDeviceCreateFlags -> Int -> VkDeviceCreateFlags)
-> (VkDeviceCreateFlags -> Int -> VkDeviceCreateFlags)
-> (VkDeviceCreateFlags -> Int -> VkDeviceCreateFlags)
-> (VkDeviceCreateFlags -> Int -> Bool)
-> (VkDeviceCreateFlags -> Maybe Int)
-> (VkDeviceCreateFlags -> Int)
-> (VkDeviceCreateFlags -> Bool)
-> (VkDeviceCreateFlags -> Int -> VkDeviceCreateFlags)
-> (VkDeviceCreateFlags -> Int -> VkDeviceCreateFlags)
-> (VkDeviceCreateFlags -> Int -> VkDeviceCreateFlags)
-> (VkDeviceCreateFlags -> Int -> VkDeviceCreateFlags)
-> (VkDeviceCreateFlags -> Int -> VkDeviceCreateFlags)
-> (VkDeviceCreateFlags -> Int -> VkDeviceCreateFlags)
-> (VkDeviceCreateFlags -> Int)
-> Bits VkDeviceCreateFlags
Int -> VkDeviceCreateFlags
VkDeviceCreateFlags -> Bool
VkDeviceCreateFlags -> Int
VkDeviceCreateFlags -> Maybe Int
VkDeviceCreateFlags -> VkDeviceCreateFlags
VkDeviceCreateFlags -> Int -> Bool
VkDeviceCreateFlags -> Int -> VkDeviceCreateFlags
VkDeviceCreateFlags -> VkDeviceCreateFlags -> VkDeviceCreateFlags
forall a.
Eq a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
popCount :: VkDeviceCreateFlags -> Int
$cpopCount :: VkDeviceCreateFlags -> Int
rotateR :: VkDeviceCreateFlags -> Int -> VkDeviceCreateFlags
$crotateR :: VkDeviceCreateFlags -> Int -> VkDeviceCreateFlags
rotateL :: VkDeviceCreateFlags -> Int -> VkDeviceCreateFlags
$crotateL :: VkDeviceCreateFlags -> Int -> VkDeviceCreateFlags
unsafeShiftR :: VkDeviceCreateFlags -> Int -> VkDeviceCreateFlags
$cunsafeShiftR :: VkDeviceCreateFlags -> Int -> VkDeviceCreateFlags
shiftR :: VkDeviceCreateFlags -> Int -> VkDeviceCreateFlags
$cshiftR :: VkDeviceCreateFlags -> Int -> VkDeviceCreateFlags
unsafeShiftL :: VkDeviceCreateFlags -> Int -> VkDeviceCreateFlags
$cunsafeShiftL :: VkDeviceCreateFlags -> Int -> VkDeviceCreateFlags
shiftL :: VkDeviceCreateFlags -> Int -> VkDeviceCreateFlags
$cshiftL :: VkDeviceCreateFlags -> Int -> VkDeviceCreateFlags
isSigned :: VkDeviceCreateFlags -> Bool
$cisSigned :: VkDeviceCreateFlags -> Bool
bitSize :: VkDeviceCreateFlags -> Int
$cbitSize :: VkDeviceCreateFlags -> Int
bitSizeMaybe :: VkDeviceCreateFlags -> Maybe Int
$cbitSizeMaybe :: VkDeviceCreateFlags -> Maybe Int
testBit :: VkDeviceCreateFlags -> Int -> Bool
$ctestBit :: VkDeviceCreateFlags -> Int -> Bool
complementBit :: VkDeviceCreateFlags -> Int -> VkDeviceCreateFlags
$ccomplementBit :: VkDeviceCreateFlags -> Int -> VkDeviceCreateFlags
clearBit :: VkDeviceCreateFlags -> Int -> VkDeviceCreateFlags
$cclearBit :: VkDeviceCreateFlags -> Int -> VkDeviceCreateFlags
setBit :: VkDeviceCreateFlags -> Int -> VkDeviceCreateFlags
$csetBit :: VkDeviceCreateFlags -> Int -> VkDeviceCreateFlags
bit :: Int -> VkDeviceCreateFlags
$cbit :: Int -> VkDeviceCreateFlags
zeroBits :: VkDeviceCreateFlags
$czeroBits :: VkDeviceCreateFlags
rotate :: VkDeviceCreateFlags -> Int -> VkDeviceCreateFlags
$crotate :: VkDeviceCreateFlags -> Int -> VkDeviceCreateFlags
shift :: VkDeviceCreateFlags -> Int -> VkDeviceCreateFlags
$cshift :: VkDeviceCreateFlags -> Int -> VkDeviceCreateFlags
complement :: VkDeviceCreateFlags -> VkDeviceCreateFlags
$ccomplement :: VkDeviceCreateFlags -> VkDeviceCreateFlags
xor :: VkDeviceCreateFlags -> VkDeviceCreateFlags -> VkDeviceCreateFlags
$cxor :: VkDeviceCreateFlags -> VkDeviceCreateFlags -> VkDeviceCreateFlags
.|. :: VkDeviceCreateFlags -> VkDeviceCreateFlags -> VkDeviceCreateFlags
$c.|. :: VkDeviceCreateFlags -> VkDeviceCreateFlags -> VkDeviceCreateFlags
.&. :: VkDeviceCreateFlags -> VkDeviceCreateFlags -> VkDeviceCreateFlags
$c.&. :: VkDeviceCreateFlags -> VkDeviceCreateFlags -> VkDeviceCreateFlags
Bits, Bits VkDeviceCreateFlags
Bits VkDeviceCreateFlags
-> (VkDeviceCreateFlags -> Int)
-> (VkDeviceCreateFlags -> Int)
-> (VkDeviceCreateFlags -> Int)
-> FiniteBits VkDeviceCreateFlags
VkDeviceCreateFlags -> Int
forall b.
Bits b -> (b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
countTrailingZeros :: VkDeviceCreateFlags -> Int
$ccountTrailingZeros :: VkDeviceCreateFlags -> Int
countLeadingZeros :: VkDeviceCreateFlags -> Int
$ccountLeadingZeros :: VkDeviceCreateFlags -> Int
finiteBitSize :: VkDeviceCreateFlags -> Int
$cfiniteBitSize :: VkDeviceCreateFlags -> Int
FiniteBits, Ptr VkDeviceCreateFlags -> IO VkDeviceCreateFlags
Ptr VkDeviceCreateFlags -> Int -> IO VkDeviceCreateFlags
Ptr VkDeviceCreateFlags -> Int -> VkDeviceCreateFlags -> IO ()
Ptr VkDeviceCreateFlags -> VkDeviceCreateFlags -> IO ()
VkDeviceCreateFlags -> Int
(VkDeviceCreateFlags -> Int)
-> (VkDeviceCreateFlags -> Int)
-> (Ptr VkDeviceCreateFlags -> Int -> IO VkDeviceCreateFlags)
-> (Ptr VkDeviceCreateFlags -> Int -> VkDeviceCreateFlags -> IO ())
-> (forall b. Ptr b -> Int -> IO VkDeviceCreateFlags)
-> (forall b. Ptr b -> Int -> VkDeviceCreateFlags -> IO ())
-> (Ptr VkDeviceCreateFlags -> IO VkDeviceCreateFlags)
-> (Ptr VkDeviceCreateFlags -> VkDeviceCreateFlags -> IO ())
-> Storable VkDeviceCreateFlags
forall b. Ptr b -> Int -> IO VkDeviceCreateFlags
forall b. Ptr b -> Int -> VkDeviceCreateFlags -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr VkDeviceCreateFlags -> VkDeviceCreateFlags -> IO ()
$cpoke :: Ptr VkDeviceCreateFlags -> VkDeviceCreateFlags -> IO ()
peek :: Ptr VkDeviceCreateFlags -> IO VkDeviceCreateFlags
$cpeek :: Ptr VkDeviceCreateFlags -> IO VkDeviceCreateFlags
pokeByteOff :: forall b. Ptr b -> Int -> VkDeviceCreateFlags -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> VkDeviceCreateFlags -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO VkDeviceCreateFlags
$cpeekByteOff :: forall b. Ptr b -> Int -> IO VkDeviceCreateFlags
pokeElemOff :: Ptr VkDeviceCreateFlags -> Int -> VkDeviceCreateFlags -> IO ()
$cpokeElemOff :: Ptr VkDeviceCreateFlags -> Int -> VkDeviceCreateFlags -> IO ()
peekElemOff :: Ptr VkDeviceCreateFlags -> Int -> IO VkDeviceCreateFlags
$cpeekElemOff :: Ptr VkDeviceCreateFlags -> Int -> IO VkDeviceCreateFlags
alignment :: VkDeviceCreateFlags -> Int
$calignment :: VkDeviceCreateFlags -> Int
sizeOf :: VkDeviceCreateFlags -> Int
$csizeOf :: VkDeviceCreateFlags -> Int
Storable)

instance Show VkDeviceCreateFlags where
    {-# INLINE showsPrec #-}
    showsPrec :: Int -> VkDeviceCreateFlags -> ShowS
showsPrec = (Int -> VkFlags -> ShowS) -> Int -> VkDeviceCreateFlags -> ShowS
coerce (Int -> VkFlags -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec :: Int -> VkFlags -> ShowS)

instance Read VkDeviceCreateFlags where
    {-# INLINE readsPrec #-}
    readsPrec :: Int -> ReadS VkDeviceCreateFlags
readsPrec = (Int -> ReadS VkFlags) -> Int -> ReadS VkDeviceCreateFlags
coerce (Int -> ReadS VkFlags
forall a. Read a => Int -> ReadS a
readsPrec :: Int -> ReadS VkFlags)

newtype VkDirectFBSurfaceCreateFlagsEXT = VkDirectFBSurfaceCreateFlagsEXT VkFlags
                                          deriving (VkDirectFBSurfaceCreateFlagsEXT
-> VkDirectFBSurfaceCreateFlagsEXT -> Bool
(VkDirectFBSurfaceCreateFlagsEXT
 -> VkDirectFBSurfaceCreateFlagsEXT -> Bool)
-> (VkDirectFBSurfaceCreateFlagsEXT
    -> VkDirectFBSurfaceCreateFlagsEXT -> Bool)
-> Eq VkDirectFBSurfaceCreateFlagsEXT
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VkDirectFBSurfaceCreateFlagsEXT
-> VkDirectFBSurfaceCreateFlagsEXT -> Bool
$c/= :: VkDirectFBSurfaceCreateFlagsEXT
-> VkDirectFBSurfaceCreateFlagsEXT -> Bool
== :: VkDirectFBSurfaceCreateFlagsEXT
-> VkDirectFBSurfaceCreateFlagsEXT -> Bool
$c== :: VkDirectFBSurfaceCreateFlagsEXT
-> VkDirectFBSurfaceCreateFlagsEXT -> Bool
Eq, Eq VkDirectFBSurfaceCreateFlagsEXT
Eq VkDirectFBSurfaceCreateFlagsEXT
-> (VkDirectFBSurfaceCreateFlagsEXT
    -> VkDirectFBSurfaceCreateFlagsEXT -> Ordering)
-> (VkDirectFBSurfaceCreateFlagsEXT
    -> VkDirectFBSurfaceCreateFlagsEXT -> Bool)
-> (VkDirectFBSurfaceCreateFlagsEXT
    -> VkDirectFBSurfaceCreateFlagsEXT -> Bool)
-> (VkDirectFBSurfaceCreateFlagsEXT
    -> VkDirectFBSurfaceCreateFlagsEXT -> Bool)
-> (VkDirectFBSurfaceCreateFlagsEXT
    -> VkDirectFBSurfaceCreateFlagsEXT -> Bool)
-> (VkDirectFBSurfaceCreateFlagsEXT
    -> VkDirectFBSurfaceCreateFlagsEXT
    -> VkDirectFBSurfaceCreateFlagsEXT)
-> (VkDirectFBSurfaceCreateFlagsEXT
    -> VkDirectFBSurfaceCreateFlagsEXT
    -> VkDirectFBSurfaceCreateFlagsEXT)
-> Ord VkDirectFBSurfaceCreateFlagsEXT
VkDirectFBSurfaceCreateFlagsEXT
-> VkDirectFBSurfaceCreateFlagsEXT -> Bool
VkDirectFBSurfaceCreateFlagsEXT
-> VkDirectFBSurfaceCreateFlagsEXT -> Ordering
VkDirectFBSurfaceCreateFlagsEXT
-> VkDirectFBSurfaceCreateFlagsEXT
-> VkDirectFBSurfaceCreateFlagsEXT
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: VkDirectFBSurfaceCreateFlagsEXT
-> VkDirectFBSurfaceCreateFlagsEXT
-> VkDirectFBSurfaceCreateFlagsEXT
$cmin :: VkDirectFBSurfaceCreateFlagsEXT
-> VkDirectFBSurfaceCreateFlagsEXT
-> VkDirectFBSurfaceCreateFlagsEXT
max :: VkDirectFBSurfaceCreateFlagsEXT
-> VkDirectFBSurfaceCreateFlagsEXT
-> VkDirectFBSurfaceCreateFlagsEXT
$cmax :: VkDirectFBSurfaceCreateFlagsEXT
-> VkDirectFBSurfaceCreateFlagsEXT
-> VkDirectFBSurfaceCreateFlagsEXT
>= :: VkDirectFBSurfaceCreateFlagsEXT
-> VkDirectFBSurfaceCreateFlagsEXT -> Bool
$c>= :: VkDirectFBSurfaceCreateFlagsEXT
-> VkDirectFBSurfaceCreateFlagsEXT -> Bool
> :: VkDirectFBSurfaceCreateFlagsEXT
-> VkDirectFBSurfaceCreateFlagsEXT -> Bool
$c> :: VkDirectFBSurfaceCreateFlagsEXT
-> VkDirectFBSurfaceCreateFlagsEXT -> Bool
<= :: VkDirectFBSurfaceCreateFlagsEXT
-> VkDirectFBSurfaceCreateFlagsEXT -> Bool
$c<= :: VkDirectFBSurfaceCreateFlagsEXT
-> VkDirectFBSurfaceCreateFlagsEXT -> Bool
< :: VkDirectFBSurfaceCreateFlagsEXT
-> VkDirectFBSurfaceCreateFlagsEXT -> Bool
$c< :: VkDirectFBSurfaceCreateFlagsEXT
-> VkDirectFBSurfaceCreateFlagsEXT -> Bool
compare :: VkDirectFBSurfaceCreateFlagsEXT
-> VkDirectFBSurfaceCreateFlagsEXT -> Ordering
$ccompare :: VkDirectFBSurfaceCreateFlagsEXT
-> VkDirectFBSurfaceCreateFlagsEXT -> Ordering
Ord, Int -> VkDirectFBSurfaceCreateFlagsEXT
VkDirectFBSurfaceCreateFlagsEXT -> Int
VkDirectFBSurfaceCreateFlagsEXT
-> [VkDirectFBSurfaceCreateFlagsEXT]
VkDirectFBSurfaceCreateFlagsEXT -> VkDirectFBSurfaceCreateFlagsEXT
VkDirectFBSurfaceCreateFlagsEXT
-> VkDirectFBSurfaceCreateFlagsEXT
-> [VkDirectFBSurfaceCreateFlagsEXT]
VkDirectFBSurfaceCreateFlagsEXT
-> VkDirectFBSurfaceCreateFlagsEXT
-> VkDirectFBSurfaceCreateFlagsEXT
-> [VkDirectFBSurfaceCreateFlagsEXT]
(VkDirectFBSurfaceCreateFlagsEXT
 -> VkDirectFBSurfaceCreateFlagsEXT)
-> (VkDirectFBSurfaceCreateFlagsEXT
    -> VkDirectFBSurfaceCreateFlagsEXT)
-> (Int -> VkDirectFBSurfaceCreateFlagsEXT)
-> (VkDirectFBSurfaceCreateFlagsEXT -> Int)
-> (VkDirectFBSurfaceCreateFlagsEXT
    -> [VkDirectFBSurfaceCreateFlagsEXT])
-> (VkDirectFBSurfaceCreateFlagsEXT
    -> VkDirectFBSurfaceCreateFlagsEXT
    -> [VkDirectFBSurfaceCreateFlagsEXT])
-> (VkDirectFBSurfaceCreateFlagsEXT
    -> VkDirectFBSurfaceCreateFlagsEXT
    -> [VkDirectFBSurfaceCreateFlagsEXT])
-> (VkDirectFBSurfaceCreateFlagsEXT
    -> VkDirectFBSurfaceCreateFlagsEXT
    -> VkDirectFBSurfaceCreateFlagsEXT
    -> [VkDirectFBSurfaceCreateFlagsEXT])
-> Enum VkDirectFBSurfaceCreateFlagsEXT
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: VkDirectFBSurfaceCreateFlagsEXT
-> VkDirectFBSurfaceCreateFlagsEXT
-> VkDirectFBSurfaceCreateFlagsEXT
-> [VkDirectFBSurfaceCreateFlagsEXT]
$cenumFromThenTo :: VkDirectFBSurfaceCreateFlagsEXT
-> VkDirectFBSurfaceCreateFlagsEXT
-> VkDirectFBSurfaceCreateFlagsEXT
-> [VkDirectFBSurfaceCreateFlagsEXT]
enumFromTo :: VkDirectFBSurfaceCreateFlagsEXT
-> VkDirectFBSurfaceCreateFlagsEXT
-> [VkDirectFBSurfaceCreateFlagsEXT]
$cenumFromTo :: VkDirectFBSurfaceCreateFlagsEXT
-> VkDirectFBSurfaceCreateFlagsEXT
-> [VkDirectFBSurfaceCreateFlagsEXT]
enumFromThen :: VkDirectFBSurfaceCreateFlagsEXT
-> VkDirectFBSurfaceCreateFlagsEXT
-> [VkDirectFBSurfaceCreateFlagsEXT]
$cenumFromThen :: VkDirectFBSurfaceCreateFlagsEXT
-> VkDirectFBSurfaceCreateFlagsEXT
-> [VkDirectFBSurfaceCreateFlagsEXT]
enumFrom :: VkDirectFBSurfaceCreateFlagsEXT
-> [VkDirectFBSurfaceCreateFlagsEXT]
$cenumFrom :: VkDirectFBSurfaceCreateFlagsEXT
-> [VkDirectFBSurfaceCreateFlagsEXT]
fromEnum :: VkDirectFBSurfaceCreateFlagsEXT -> Int
$cfromEnum :: VkDirectFBSurfaceCreateFlagsEXT -> Int
toEnum :: Int -> VkDirectFBSurfaceCreateFlagsEXT
$ctoEnum :: Int -> VkDirectFBSurfaceCreateFlagsEXT
pred :: VkDirectFBSurfaceCreateFlagsEXT -> VkDirectFBSurfaceCreateFlagsEXT
$cpred :: VkDirectFBSurfaceCreateFlagsEXT -> VkDirectFBSurfaceCreateFlagsEXT
succ :: VkDirectFBSurfaceCreateFlagsEXT -> VkDirectFBSurfaceCreateFlagsEXT
$csucc :: VkDirectFBSurfaceCreateFlagsEXT -> VkDirectFBSurfaceCreateFlagsEXT
Enum, Eq VkDirectFBSurfaceCreateFlagsEXT
VkDirectFBSurfaceCreateFlagsEXT
Eq VkDirectFBSurfaceCreateFlagsEXT
-> (VkDirectFBSurfaceCreateFlagsEXT
    -> VkDirectFBSurfaceCreateFlagsEXT
    -> VkDirectFBSurfaceCreateFlagsEXT)
-> (VkDirectFBSurfaceCreateFlagsEXT
    -> VkDirectFBSurfaceCreateFlagsEXT
    -> VkDirectFBSurfaceCreateFlagsEXT)
-> (VkDirectFBSurfaceCreateFlagsEXT
    -> VkDirectFBSurfaceCreateFlagsEXT
    -> VkDirectFBSurfaceCreateFlagsEXT)
-> (VkDirectFBSurfaceCreateFlagsEXT
    -> VkDirectFBSurfaceCreateFlagsEXT)
-> (VkDirectFBSurfaceCreateFlagsEXT
    -> Int -> VkDirectFBSurfaceCreateFlagsEXT)
-> (VkDirectFBSurfaceCreateFlagsEXT
    -> Int -> VkDirectFBSurfaceCreateFlagsEXT)
-> VkDirectFBSurfaceCreateFlagsEXT
-> (Int -> VkDirectFBSurfaceCreateFlagsEXT)
-> (VkDirectFBSurfaceCreateFlagsEXT
    -> Int -> VkDirectFBSurfaceCreateFlagsEXT)
-> (VkDirectFBSurfaceCreateFlagsEXT
    -> Int -> VkDirectFBSurfaceCreateFlagsEXT)
-> (VkDirectFBSurfaceCreateFlagsEXT
    -> Int -> VkDirectFBSurfaceCreateFlagsEXT)
-> (VkDirectFBSurfaceCreateFlagsEXT -> Int -> Bool)
-> (VkDirectFBSurfaceCreateFlagsEXT -> Maybe Int)
-> (VkDirectFBSurfaceCreateFlagsEXT -> Int)
-> (VkDirectFBSurfaceCreateFlagsEXT -> Bool)
-> (VkDirectFBSurfaceCreateFlagsEXT
    -> Int -> VkDirectFBSurfaceCreateFlagsEXT)
-> (VkDirectFBSurfaceCreateFlagsEXT
    -> Int -> VkDirectFBSurfaceCreateFlagsEXT)
-> (VkDirectFBSurfaceCreateFlagsEXT
    -> Int -> VkDirectFBSurfaceCreateFlagsEXT)
-> (VkDirectFBSurfaceCreateFlagsEXT
    -> Int -> VkDirectFBSurfaceCreateFlagsEXT)
-> (VkDirectFBSurfaceCreateFlagsEXT
    -> Int -> VkDirectFBSurfaceCreateFlagsEXT)
-> (VkDirectFBSurfaceCreateFlagsEXT
    -> Int -> VkDirectFBSurfaceCreateFlagsEXT)
-> (VkDirectFBSurfaceCreateFlagsEXT -> Int)
-> Bits VkDirectFBSurfaceCreateFlagsEXT
Int -> VkDirectFBSurfaceCreateFlagsEXT
VkDirectFBSurfaceCreateFlagsEXT -> Bool
VkDirectFBSurfaceCreateFlagsEXT -> Int
VkDirectFBSurfaceCreateFlagsEXT -> Maybe Int
VkDirectFBSurfaceCreateFlagsEXT -> VkDirectFBSurfaceCreateFlagsEXT
VkDirectFBSurfaceCreateFlagsEXT -> Int -> Bool
VkDirectFBSurfaceCreateFlagsEXT
-> Int -> VkDirectFBSurfaceCreateFlagsEXT
VkDirectFBSurfaceCreateFlagsEXT
-> VkDirectFBSurfaceCreateFlagsEXT
-> VkDirectFBSurfaceCreateFlagsEXT
forall a.
Eq a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
popCount :: VkDirectFBSurfaceCreateFlagsEXT -> Int
$cpopCount :: VkDirectFBSurfaceCreateFlagsEXT -> Int
rotateR :: VkDirectFBSurfaceCreateFlagsEXT
-> Int -> VkDirectFBSurfaceCreateFlagsEXT
$crotateR :: VkDirectFBSurfaceCreateFlagsEXT
-> Int -> VkDirectFBSurfaceCreateFlagsEXT
rotateL :: VkDirectFBSurfaceCreateFlagsEXT
-> Int -> VkDirectFBSurfaceCreateFlagsEXT
$crotateL :: VkDirectFBSurfaceCreateFlagsEXT
-> Int -> VkDirectFBSurfaceCreateFlagsEXT
unsafeShiftR :: VkDirectFBSurfaceCreateFlagsEXT
-> Int -> VkDirectFBSurfaceCreateFlagsEXT
$cunsafeShiftR :: VkDirectFBSurfaceCreateFlagsEXT
-> Int -> VkDirectFBSurfaceCreateFlagsEXT
shiftR :: VkDirectFBSurfaceCreateFlagsEXT
-> Int -> VkDirectFBSurfaceCreateFlagsEXT
$cshiftR :: VkDirectFBSurfaceCreateFlagsEXT
-> Int -> VkDirectFBSurfaceCreateFlagsEXT
unsafeShiftL :: VkDirectFBSurfaceCreateFlagsEXT
-> Int -> VkDirectFBSurfaceCreateFlagsEXT
$cunsafeShiftL :: VkDirectFBSurfaceCreateFlagsEXT
-> Int -> VkDirectFBSurfaceCreateFlagsEXT
shiftL :: VkDirectFBSurfaceCreateFlagsEXT
-> Int -> VkDirectFBSurfaceCreateFlagsEXT
$cshiftL :: VkDirectFBSurfaceCreateFlagsEXT
-> Int -> VkDirectFBSurfaceCreateFlagsEXT
isSigned :: VkDirectFBSurfaceCreateFlagsEXT -> Bool
$cisSigned :: VkDirectFBSurfaceCreateFlagsEXT -> Bool
bitSize :: VkDirectFBSurfaceCreateFlagsEXT -> Int
$cbitSize :: VkDirectFBSurfaceCreateFlagsEXT -> Int
bitSizeMaybe :: VkDirectFBSurfaceCreateFlagsEXT -> Maybe Int
$cbitSizeMaybe :: VkDirectFBSurfaceCreateFlagsEXT -> Maybe Int
testBit :: VkDirectFBSurfaceCreateFlagsEXT -> Int -> Bool
$ctestBit :: VkDirectFBSurfaceCreateFlagsEXT -> Int -> Bool
complementBit :: VkDirectFBSurfaceCreateFlagsEXT
-> Int -> VkDirectFBSurfaceCreateFlagsEXT
$ccomplementBit :: VkDirectFBSurfaceCreateFlagsEXT
-> Int -> VkDirectFBSurfaceCreateFlagsEXT
clearBit :: VkDirectFBSurfaceCreateFlagsEXT
-> Int -> VkDirectFBSurfaceCreateFlagsEXT
$cclearBit :: VkDirectFBSurfaceCreateFlagsEXT
-> Int -> VkDirectFBSurfaceCreateFlagsEXT
setBit :: VkDirectFBSurfaceCreateFlagsEXT
-> Int -> VkDirectFBSurfaceCreateFlagsEXT
$csetBit :: VkDirectFBSurfaceCreateFlagsEXT
-> Int -> VkDirectFBSurfaceCreateFlagsEXT
bit :: Int -> VkDirectFBSurfaceCreateFlagsEXT
$cbit :: Int -> VkDirectFBSurfaceCreateFlagsEXT
zeroBits :: VkDirectFBSurfaceCreateFlagsEXT
$czeroBits :: VkDirectFBSurfaceCreateFlagsEXT
rotate :: VkDirectFBSurfaceCreateFlagsEXT
-> Int -> VkDirectFBSurfaceCreateFlagsEXT
$crotate :: VkDirectFBSurfaceCreateFlagsEXT
-> Int -> VkDirectFBSurfaceCreateFlagsEXT
shift :: VkDirectFBSurfaceCreateFlagsEXT
-> Int -> VkDirectFBSurfaceCreateFlagsEXT
$cshift :: VkDirectFBSurfaceCreateFlagsEXT
-> Int -> VkDirectFBSurfaceCreateFlagsEXT
complement :: VkDirectFBSurfaceCreateFlagsEXT -> VkDirectFBSurfaceCreateFlagsEXT
$ccomplement :: VkDirectFBSurfaceCreateFlagsEXT -> VkDirectFBSurfaceCreateFlagsEXT
xor :: VkDirectFBSurfaceCreateFlagsEXT
-> VkDirectFBSurfaceCreateFlagsEXT
-> VkDirectFBSurfaceCreateFlagsEXT
$cxor :: VkDirectFBSurfaceCreateFlagsEXT
-> VkDirectFBSurfaceCreateFlagsEXT
-> VkDirectFBSurfaceCreateFlagsEXT
.|. :: VkDirectFBSurfaceCreateFlagsEXT
-> VkDirectFBSurfaceCreateFlagsEXT
-> VkDirectFBSurfaceCreateFlagsEXT
$c.|. :: VkDirectFBSurfaceCreateFlagsEXT
-> VkDirectFBSurfaceCreateFlagsEXT
-> VkDirectFBSurfaceCreateFlagsEXT
.&. :: VkDirectFBSurfaceCreateFlagsEXT
-> VkDirectFBSurfaceCreateFlagsEXT
-> VkDirectFBSurfaceCreateFlagsEXT
$c.&. :: VkDirectFBSurfaceCreateFlagsEXT
-> VkDirectFBSurfaceCreateFlagsEXT
-> VkDirectFBSurfaceCreateFlagsEXT
Bits, Bits VkDirectFBSurfaceCreateFlagsEXT
Bits VkDirectFBSurfaceCreateFlagsEXT
-> (VkDirectFBSurfaceCreateFlagsEXT -> Int)
-> (VkDirectFBSurfaceCreateFlagsEXT -> Int)
-> (VkDirectFBSurfaceCreateFlagsEXT -> Int)
-> FiniteBits VkDirectFBSurfaceCreateFlagsEXT
VkDirectFBSurfaceCreateFlagsEXT -> Int
forall b.
Bits b -> (b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
countTrailingZeros :: VkDirectFBSurfaceCreateFlagsEXT -> Int
$ccountTrailingZeros :: VkDirectFBSurfaceCreateFlagsEXT -> Int
countLeadingZeros :: VkDirectFBSurfaceCreateFlagsEXT -> Int
$ccountLeadingZeros :: VkDirectFBSurfaceCreateFlagsEXT -> Int
finiteBitSize :: VkDirectFBSurfaceCreateFlagsEXT -> Int
$cfiniteBitSize :: VkDirectFBSurfaceCreateFlagsEXT -> Int
FiniteBits, Ptr VkDirectFBSurfaceCreateFlagsEXT
-> IO VkDirectFBSurfaceCreateFlagsEXT
Ptr VkDirectFBSurfaceCreateFlagsEXT
-> Int -> IO VkDirectFBSurfaceCreateFlagsEXT
Ptr VkDirectFBSurfaceCreateFlagsEXT
-> Int -> VkDirectFBSurfaceCreateFlagsEXT -> IO ()
Ptr VkDirectFBSurfaceCreateFlagsEXT
-> VkDirectFBSurfaceCreateFlagsEXT -> IO ()
VkDirectFBSurfaceCreateFlagsEXT -> Int
(VkDirectFBSurfaceCreateFlagsEXT -> Int)
-> (VkDirectFBSurfaceCreateFlagsEXT -> Int)
-> (Ptr VkDirectFBSurfaceCreateFlagsEXT
    -> Int -> IO VkDirectFBSurfaceCreateFlagsEXT)
-> (Ptr VkDirectFBSurfaceCreateFlagsEXT
    -> Int -> VkDirectFBSurfaceCreateFlagsEXT -> IO ())
-> (forall b. Ptr b -> Int -> IO VkDirectFBSurfaceCreateFlagsEXT)
-> (forall b.
    Ptr b -> Int -> VkDirectFBSurfaceCreateFlagsEXT -> IO ())
-> (Ptr VkDirectFBSurfaceCreateFlagsEXT
    -> IO VkDirectFBSurfaceCreateFlagsEXT)
-> (Ptr VkDirectFBSurfaceCreateFlagsEXT
    -> VkDirectFBSurfaceCreateFlagsEXT -> IO ())
-> Storable VkDirectFBSurfaceCreateFlagsEXT
forall b. Ptr b -> Int -> IO VkDirectFBSurfaceCreateFlagsEXT
forall b. Ptr b -> Int -> VkDirectFBSurfaceCreateFlagsEXT -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr VkDirectFBSurfaceCreateFlagsEXT
-> VkDirectFBSurfaceCreateFlagsEXT -> IO ()
$cpoke :: Ptr VkDirectFBSurfaceCreateFlagsEXT
-> VkDirectFBSurfaceCreateFlagsEXT -> IO ()
peek :: Ptr VkDirectFBSurfaceCreateFlagsEXT
-> IO VkDirectFBSurfaceCreateFlagsEXT
$cpeek :: Ptr VkDirectFBSurfaceCreateFlagsEXT
-> IO VkDirectFBSurfaceCreateFlagsEXT
pokeByteOff :: forall b. Ptr b -> Int -> VkDirectFBSurfaceCreateFlagsEXT -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> VkDirectFBSurfaceCreateFlagsEXT -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO VkDirectFBSurfaceCreateFlagsEXT
$cpeekByteOff :: forall b. Ptr b -> Int -> IO VkDirectFBSurfaceCreateFlagsEXT
pokeElemOff :: Ptr VkDirectFBSurfaceCreateFlagsEXT
-> Int -> VkDirectFBSurfaceCreateFlagsEXT -> IO ()
$cpokeElemOff :: Ptr VkDirectFBSurfaceCreateFlagsEXT
-> Int -> VkDirectFBSurfaceCreateFlagsEXT -> IO ()
peekElemOff :: Ptr VkDirectFBSurfaceCreateFlagsEXT
-> Int -> IO VkDirectFBSurfaceCreateFlagsEXT
$cpeekElemOff :: Ptr VkDirectFBSurfaceCreateFlagsEXT
-> Int -> IO VkDirectFBSurfaceCreateFlagsEXT
alignment :: VkDirectFBSurfaceCreateFlagsEXT -> Int
$calignment :: VkDirectFBSurfaceCreateFlagsEXT -> Int
sizeOf :: VkDirectFBSurfaceCreateFlagsEXT -> Int
$csizeOf :: VkDirectFBSurfaceCreateFlagsEXT -> Int
Storable)

instance Show VkDirectFBSurfaceCreateFlagsEXT where
    {-# INLINE showsPrec #-}
    showsPrec :: Int -> VkDirectFBSurfaceCreateFlagsEXT -> ShowS
showsPrec = (Int -> VkFlags -> ShowS)
-> Int -> VkDirectFBSurfaceCreateFlagsEXT -> ShowS
coerce (Int -> VkFlags -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec :: Int -> VkFlags -> ShowS)

instance Read VkDirectFBSurfaceCreateFlagsEXT where
    {-# INLINE readsPrec #-}
    readsPrec :: Int -> ReadS VkDirectFBSurfaceCreateFlagsEXT
readsPrec = (Int -> ReadS VkFlags)
-> Int -> ReadS VkDirectFBSurfaceCreateFlagsEXT
coerce (Int -> ReadS VkFlags
forall a. Read a => Int -> ReadS a
readsPrec :: Int -> ReadS VkFlags)

newtype VkDisplayModeCreateFlagsKHR = VkDisplayModeCreateFlagsKHR VkFlags
                                      deriving (VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR -> Bool
(VkDisplayModeCreateFlagsKHR
 -> VkDisplayModeCreateFlagsKHR -> Bool)
-> (VkDisplayModeCreateFlagsKHR
    -> VkDisplayModeCreateFlagsKHR -> Bool)
-> Eq VkDisplayModeCreateFlagsKHR
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR -> Bool
$c/= :: VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR -> Bool
== :: VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR -> Bool
$c== :: VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR -> Bool
Eq, Eq VkDisplayModeCreateFlagsKHR
Eq VkDisplayModeCreateFlagsKHR
-> (VkDisplayModeCreateFlagsKHR
    -> VkDisplayModeCreateFlagsKHR -> Ordering)
-> (VkDisplayModeCreateFlagsKHR
    -> VkDisplayModeCreateFlagsKHR -> Bool)
-> (VkDisplayModeCreateFlagsKHR
    -> VkDisplayModeCreateFlagsKHR -> Bool)
-> (VkDisplayModeCreateFlagsKHR
    -> VkDisplayModeCreateFlagsKHR -> Bool)
-> (VkDisplayModeCreateFlagsKHR
    -> VkDisplayModeCreateFlagsKHR -> Bool)
-> (VkDisplayModeCreateFlagsKHR
    -> VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR)
-> (VkDisplayModeCreateFlagsKHR
    -> VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR)
-> Ord VkDisplayModeCreateFlagsKHR
VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR -> Bool
VkDisplayModeCreateFlagsKHR
-> VkDisplayModeCreateFlagsKHR -> Ordering
VkDisplayModeCreateFlagsKHR
-> VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: VkDisplayModeCreateFlagsKHR
-> VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR
$cmin :: VkDisplayModeCreateFlagsKHR
-> VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR
max :: VkDisplayModeCreateFlagsKHR
-> VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR
$cmax :: VkDisplayModeCreateFlagsKHR
-> VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR
>= :: VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR -> Bool
$c>= :: VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR -> Bool
> :: VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR -> Bool
$c> :: VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR -> Bool
<= :: VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR -> Bool
$c<= :: VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR -> Bool
< :: VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR -> Bool
$c< :: VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR -> Bool
compare :: VkDisplayModeCreateFlagsKHR
-> VkDisplayModeCreateFlagsKHR -> Ordering
$ccompare :: VkDisplayModeCreateFlagsKHR
-> VkDisplayModeCreateFlagsKHR -> Ordering
Ord, Int -> VkDisplayModeCreateFlagsKHR
VkDisplayModeCreateFlagsKHR -> Int
VkDisplayModeCreateFlagsKHR -> [VkDisplayModeCreateFlagsKHR]
VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR
VkDisplayModeCreateFlagsKHR
-> VkDisplayModeCreateFlagsKHR -> [VkDisplayModeCreateFlagsKHR]
VkDisplayModeCreateFlagsKHR
-> VkDisplayModeCreateFlagsKHR
-> VkDisplayModeCreateFlagsKHR
-> [VkDisplayModeCreateFlagsKHR]
(VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR)
-> (VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR)
-> (Int -> VkDisplayModeCreateFlagsKHR)
-> (VkDisplayModeCreateFlagsKHR -> Int)
-> (VkDisplayModeCreateFlagsKHR -> [VkDisplayModeCreateFlagsKHR])
-> (VkDisplayModeCreateFlagsKHR
    -> VkDisplayModeCreateFlagsKHR -> [VkDisplayModeCreateFlagsKHR])
-> (VkDisplayModeCreateFlagsKHR
    -> VkDisplayModeCreateFlagsKHR -> [VkDisplayModeCreateFlagsKHR])
-> (VkDisplayModeCreateFlagsKHR
    -> VkDisplayModeCreateFlagsKHR
    -> VkDisplayModeCreateFlagsKHR
    -> [VkDisplayModeCreateFlagsKHR])
-> Enum VkDisplayModeCreateFlagsKHR
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: VkDisplayModeCreateFlagsKHR
-> VkDisplayModeCreateFlagsKHR
-> VkDisplayModeCreateFlagsKHR
-> [VkDisplayModeCreateFlagsKHR]
$cenumFromThenTo :: VkDisplayModeCreateFlagsKHR
-> VkDisplayModeCreateFlagsKHR
-> VkDisplayModeCreateFlagsKHR
-> [VkDisplayModeCreateFlagsKHR]
enumFromTo :: VkDisplayModeCreateFlagsKHR
-> VkDisplayModeCreateFlagsKHR -> [VkDisplayModeCreateFlagsKHR]
$cenumFromTo :: VkDisplayModeCreateFlagsKHR
-> VkDisplayModeCreateFlagsKHR -> [VkDisplayModeCreateFlagsKHR]
enumFromThen :: VkDisplayModeCreateFlagsKHR
-> VkDisplayModeCreateFlagsKHR -> [VkDisplayModeCreateFlagsKHR]
$cenumFromThen :: VkDisplayModeCreateFlagsKHR
-> VkDisplayModeCreateFlagsKHR -> [VkDisplayModeCreateFlagsKHR]
enumFrom :: VkDisplayModeCreateFlagsKHR -> [VkDisplayModeCreateFlagsKHR]
$cenumFrom :: VkDisplayModeCreateFlagsKHR -> [VkDisplayModeCreateFlagsKHR]
fromEnum :: VkDisplayModeCreateFlagsKHR -> Int
$cfromEnum :: VkDisplayModeCreateFlagsKHR -> Int
toEnum :: Int -> VkDisplayModeCreateFlagsKHR
$ctoEnum :: Int -> VkDisplayModeCreateFlagsKHR
pred :: VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR
$cpred :: VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR
succ :: VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR
$csucc :: VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR
Enum, Eq VkDisplayModeCreateFlagsKHR
VkDisplayModeCreateFlagsKHR
Eq VkDisplayModeCreateFlagsKHR
-> (VkDisplayModeCreateFlagsKHR
    -> VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR)
-> (VkDisplayModeCreateFlagsKHR
    -> VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR)
-> (VkDisplayModeCreateFlagsKHR
    -> VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR)
-> (VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR)
-> (VkDisplayModeCreateFlagsKHR
    -> Int -> VkDisplayModeCreateFlagsKHR)
-> (VkDisplayModeCreateFlagsKHR
    -> Int -> VkDisplayModeCreateFlagsKHR)
-> VkDisplayModeCreateFlagsKHR
-> (Int -> VkDisplayModeCreateFlagsKHR)
-> (VkDisplayModeCreateFlagsKHR
    -> Int -> VkDisplayModeCreateFlagsKHR)
-> (VkDisplayModeCreateFlagsKHR
    -> Int -> VkDisplayModeCreateFlagsKHR)
-> (VkDisplayModeCreateFlagsKHR
    -> Int -> VkDisplayModeCreateFlagsKHR)
-> (VkDisplayModeCreateFlagsKHR -> Int -> Bool)
-> (VkDisplayModeCreateFlagsKHR -> Maybe Int)
-> (VkDisplayModeCreateFlagsKHR -> Int)
-> (VkDisplayModeCreateFlagsKHR -> Bool)
-> (VkDisplayModeCreateFlagsKHR
    -> Int -> VkDisplayModeCreateFlagsKHR)
-> (VkDisplayModeCreateFlagsKHR
    -> Int -> VkDisplayModeCreateFlagsKHR)
-> (VkDisplayModeCreateFlagsKHR
    -> Int -> VkDisplayModeCreateFlagsKHR)
-> (VkDisplayModeCreateFlagsKHR
    -> Int -> VkDisplayModeCreateFlagsKHR)
-> (VkDisplayModeCreateFlagsKHR
    -> Int -> VkDisplayModeCreateFlagsKHR)
-> (VkDisplayModeCreateFlagsKHR
    -> Int -> VkDisplayModeCreateFlagsKHR)
-> (VkDisplayModeCreateFlagsKHR -> Int)
-> Bits VkDisplayModeCreateFlagsKHR
Int -> VkDisplayModeCreateFlagsKHR
VkDisplayModeCreateFlagsKHR -> Bool
VkDisplayModeCreateFlagsKHR -> Int
VkDisplayModeCreateFlagsKHR -> Maybe Int
VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR
VkDisplayModeCreateFlagsKHR -> Int -> Bool
VkDisplayModeCreateFlagsKHR -> Int -> VkDisplayModeCreateFlagsKHR
VkDisplayModeCreateFlagsKHR
-> VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR
forall a.
Eq a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
popCount :: VkDisplayModeCreateFlagsKHR -> Int
$cpopCount :: VkDisplayModeCreateFlagsKHR -> Int
rotateR :: VkDisplayModeCreateFlagsKHR -> Int -> VkDisplayModeCreateFlagsKHR
$crotateR :: VkDisplayModeCreateFlagsKHR -> Int -> VkDisplayModeCreateFlagsKHR
rotateL :: VkDisplayModeCreateFlagsKHR -> Int -> VkDisplayModeCreateFlagsKHR
$crotateL :: VkDisplayModeCreateFlagsKHR -> Int -> VkDisplayModeCreateFlagsKHR
unsafeShiftR :: VkDisplayModeCreateFlagsKHR -> Int -> VkDisplayModeCreateFlagsKHR
$cunsafeShiftR :: VkDisplayModeCreateFlagsKHR -> Int -> VkDisplayModeCreateFlagsKHR
shiftR :: VkDisplayModeCreateFlagsKHR -> Int -> VkDisplayModeCreateFlagsKHR
$cshiftR :: VkDisplayModeCreateFlagsKHR -> Int -> VkDisplayModeCreateFlagsKHR
unsafeShiftL :: VkDisplayModeCreateFlagsKHR -> Int -> VkDisplayModeCreateFlagsKHR
$cunsafeShiftL :: VkDisplayModeCreateFlagsKHR -> Int -> VkDisplayModeCreateFlagsKHR
shiftL :: VkDisplayModeCreateFlagsKHR -> Int -> VkDisplayModeCreateFlagsKHR
$cshiftL :: VkDisplayModeCreateFlagsKHR -> Int -> VkDisplayModeCreateFlagsKHR
isSigned :: VkDisplayModeCreateFlagsKHR -> Bool
$cisSigned :: VkDisplayModeCreateFlagsKHR -> Bool
bitSize :: VkDisplayModeCreateFlagsKHR -> Int
$cbitSize :: VkDisplayModeCreateFlagsKHR -> Int
bitSizeMaybe :: VkDisplayModeCreateFlagsKHR -> Maybe Int
$cbitSizeMaybe :: VkDisplayModeCreateFlagsKHR -> Maybe Int
testBit :: VkDisplayModeCreateFlagsKHR -> Int -> Bool
$ctestBit :: VkDisplayModeCreateFlagsKHR -> Int -> Bool
complementBit :: VkDisplayModeCreateFlagsKHR -> Int -> VkDisplayModeCreateFlagsKHR
$ccomplementBit :: VkDisplayModeCreateFlagsKHR -> Int -> VkDisplayModeCreateFlagsKHR
clearBit :: VkDisplayModeCreateFlagsKHR -> Int -> VkDisplayModeCreateFlagsKHR
$cclearBit :: VkDisplayModeCreateFlagsKHR -> Int -> VkDisplayModeCreateFlagsKHR
setBit :: VkDisplayModeCreateFlagsKHR -> Int -> VkDisplayModeCreateFlagsKHR
$csetBit :: VkDisplayModeCreateFlagsKHR -> Int -> VkDisplayModeCreateFlagsKHR
bit :: Int -> VkDisplayModeCreateFlagsKHR
$cbit :: Int -> VkDisplayModeCreateFlagsKHR
zeroBits :: VkDisplayModeCreateFlagsKHR
$czeroBits :: VkDisplayModeCreateFlagsKHR
rotate :: VkDisplayModeCreateFlagsKHR -> Int -> VkDisplayModeCreateFlagsKHR
$crotate :: VkDisplayModeCreateFlagsKHR -> Int -> VkDisplayModeCreateFlagsKHR
shift :: VkDisplayModeCreateFlagsKHR -> Int -> VkDisplayModeCreateFlagsKHR
$cshift :: VkDisplayModeCreateFlagsKHR -> Int -> VkDisplayModeCreateFlagsKHR
complement :: VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR
$ccomplement :: VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR
xor :: VkDisplayModeCreateFlagsKHR
-> VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR
$cxor :: VkDisplayModeCreateFlagsKHR
-> VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR
.|. :: VkDisplayModeCreateFlagsKHR
-> VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR
$c.|. :: VkDisplayModeCreateFlagsKHR
-> VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR
.&. :: VkDisplayModeCreateFlagsKHR
-> VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR
$c.&. :: VkDisplayModeCreateFlagsKHR
-> VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR
Bits, Bits VkDisplayModeCreateFlagsKHR
Bits VkDisplayModeCreateFlagsKHR
-> (VkDisplayModeCreateFlagsKHR -> Int)
-> (VkDisplayModeCreateFlagsKHR -> Int)
-> (VkDisplayModeCreateFlagsKHR -> Int)
-> FiniteBits VkDisplayModeCreateFlagsKHR
VkDisplayModeCreateFlagsKHR -> Int
forall b.
Bits b -> (b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
countTrailingZeros :: VkDisplayModeCreateFlagsKHR -> Int
$ccountTrailingZeros :: VkDisplayModeCreateFlagsKHR -> Int
countLeadingZeros :: VkDisplayModeCreateFlagsKHR -> Int
$ccountLeadingZeros :: VkDisplayModeCreateFlagsKHR -> Int
finiteBitSize :: VkDisplayModeCreateFlagsKHR -> Int
$cfiniteBitSize :: VkDisplayModeCreateFlagsKHR -> Int
FiniteBits, Ptr VkDisplayModeCreateFlagsKHR -> IO VkDisplayModeCreateFlagsKHR
Ptr VkDisplayModeCreateFlagsKHR
-> Int -> IO VkDisplayModeCreateFlagsKHR
Ptr VkDisplayModeCreateFlagsKHR
-> Int -> VkDisplayModeCreateFlagsKHR -> IO ()
Ptr VkDisplayModeCreateFlagsKHR
-> VkDisplayModeCreateFlagsKHR -> IO ()
VkDisplayModeCreateFlagsKHR -> Int
(VkDisplayModeCreateFlagsKHR -> Int)
-> (VkDisplayModeCreateFlagsKHR -> Int)
-> (Ptr VkDisplayModeCreateFlagsKHR
    -> Int -> IO VkDisplayModeCreateFlagsKHR)
-> (Ptr VkDisplayModeCreateFlagsKHR
    -> Int -> VkDisplayModeCreateFlagsKHR -> IO ())
-> (forall b. Ptr b -> Int -> IO VkDisplayModeCreateFlagsKHR)
-> (forall b. Ptr b -> Int -> VkDisplayModeCreateFlagsKHR -> IO ())
-> (Ptr VkDisplayModeCreateFlagsKHR
    -> IO VkDisplayModeCreateFlagsKHR)
-> (Ptr VkDisplayModeCreateFlagsKHR
    -> VkDisplayModeCreateFlagsKHR -> IO ())
-> Storable VkDisplayModeCreateFlagsKHR
forall b. Ptr b -> Int -> IO VkDisplayModeCreateFlagsKHR
forall b. Ptr b -> Int -> VkDisplayModeCreateFlagsKHR -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr VkDisplayModeCreateFlagsKHR
-> VkDisplayModeCreateFlagsKHR -> IO ()
$cpoke :: Ptr VkDisplayModeCreateFlagsKHR
-> VkDisplayModeCreateFlagsKHR -> IO ()
peek :: Ptr VkDisplayModeCreateFlagsKHR -> IO VkDisplayModeCreateFlagsKHR
$cpeek :: Ptr VkDisplayModeCreateFlagsKHR -> IO VkDisplayModeCreateFlagsKHR
pokeByteOff :: forall b. Ptr b -> Int -> VkDisplayModeCreateFlagsKHR -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> VkDisplayModeCreateFlagsKHR -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO VkDisplayModeCreateFlagsKHR
$cpeekByteOff :: forall b. Ptr b -> Int -> IO VkDisplayModeCreateFlagsKHR
pokeElemOff :: Ptr VkDisplayModeCreateFlagsKHR
-> Int -> VkDisplayModeCreateFlagsKHR -> IO ()
$cpokeElemOff :: Ptr VkDisplayModeCreateFlagsKHR
-> Int -> VkDisplayModeCreateFlagsKHR -> IO ()
peekElemOff :: Ptr VkDisplayModeCreateFlagsKHR
-> Int -> IO VkDisplayModeCreateFlagsKHR
$cpeekElemOff :: Ptr VkDisplayModeCreateFlagsKHR
-> Int -> IO VkDisplayModeCreateFlagsKHR
alignment :: VkDisplayModeCreateFlagsKHR -> Int
$calignment :: VkDisplayModeCreateFlagsKHR -> Int
sizeOf :: VkDisplayModeCreateFlagsKHR -> Int
$csizeOf :: VkDisplayModeCreateFlagsKHR -> Int
Storable)

instance Show VkDisplayModeCreateFlagsKHR where
    {-# INLINE showsPrec #-}
    showsPrec :: Int -> VkDisplayModeCreateFlagsKHR -> ShowS
showsPrec = (Int -> VkFlags -> ShowS)
-> Int -> VkDisplayModeCreateFlagsKHR -> ShowS
coerce (Int -> VkFlags -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec :: Int -> VkFlags -> ShowS)

instance Read VkDisplayModeCreateFlagsKHR where
    {-# INLINE readsPrec #-}
    readsPrec :: Int -> ReadS VkDisplayModeCreateFlagsKHR
readsPrec = (Int -> ReadS VkFlags) -> Int -> ReadS VkDisplayModeCreateFlagsKHR
coerce (Int -> ReadS VkFlags
forall a. Read a => Int -> ReadS a
readsPrec :: Int -> ReadS VkFlags)

newtype VkDisplaySurfaceCreateFlagsKHR = VkDisplaySurfaceCreateFlagsKHR VkFlags
                                         deriving (VkDisplaySurfaceCreateFlagsKHR
-> VkDisplaySurfaceCreateFlagsKHR -> Bool
(VkDisplaySurfaceCreateFlagsKHR
 -> VkDisplaySurfaceCreateFlagsKHR -> Bool)
-> (VkDisplaySurfaceCreateFlagsKHR
    -> VkDisplaySurfaceCreateFlagsKHR -> Bool)
-> Eq VkDisplaySurfaceCreateFlagsKHR
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VkDisplaySurfaceCreateFlagsKHR
-> VkDisplaySurfaceCreateFlagsKHR -> Bool
$c/= :: VkDisplaySurfaceCreateFlagsKHR
-> VkDisplaySurfaceCreateFlagsKHR -> Bool
== :: VkDisplaySurfaceCreateFlagsKHR
-> VkDisplaySurfaceCreateFlagsKHR -> Bool
$c== :: VkDisplaySurfaceCreateFlagsKHR
-> VkDisplaySurfaceCreateFlagsKHR -> Bool
Eq, Eq VkDisplaySurfaceCreateFlagsKHR
Eq VkDisplaySurfaceCreateFlagsKHR
-> (VkDisplaySurfaceCreateFlagsKHR
    -> VkDisplaySurfaceCreateFlagsKHR -> Ordering)
-> (VkDisplaySurfaceCreateFlagsKHR
    -> VkDisplaySurfaceCreateFlagsKHR -> Bool)
-> (VkDisplaySurfaceCreateFlagsKHR
    -> VkDisplaySurfaceCreateFlagsKHR -> Bool)
-> (VkDisplaySurfaceCreateFlagsKHR
    -> VkDisplaySurfaceCreateFlagsKHR -> Bool)
-> (VkDisplaySurfaceCreateFlagsKHR
    -> VkDisplaySurfaceCreateFlagsKHR -> Bool)
-> (VkDisplaySurfaceCreateFlagsKHR
    -> VkDisplaySurfaceCreateFlagsKHR
    -> VkDisplaySurfaceCreateFlagsKHR)
-> (VkDisplaySurfaceCreateFlagsKHR
    -> VkDisplaySurfaceCreateFlagsKHR
    -> VkDisplaySurfaceCreateFlagsKHR)
-> Ord VkDisplaySurfaceCreateFlagsKHR
VkDisplaySurfaceCreateFlagsKHR
-> VkDisplaySurfaceCreateFlagsKHR -> Bool
VkDisplaySurfaceCreateFlagsKHR
-> VkDisplaySurfaceCreateFlagsKHR -> Ordering
VkDisplaySurfaceCreateFlagsKHR
-> VkDisplaySurfaceCreateFlagsKHR -> VkDisplaySurfaceCreateFlagsKHR
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: VkDisplaySurfaceCreateFlagsKHR
-> VkDisplaySurfaceCreateFlagsKHR -> VkDisplaySurfaceCreateFlagsKHR
$cmin :: VkDisplaySurfaceCreateFlagsKHR
-> VkDisplaySurfaceCreateFlagsKHR -> VkDisplaySurfaceCreateFlagsKHR
max :: VkDisplaySurfaceCreateFlagsKHR
-> VkDisplaySurfaceCreateFlagsKHR -> VkDisplaySurfaceCreateFlagsKHR
$cmax :: VkDisplaySurfaceCreateFlagsKHR
-> VkDisplaySurfaceCreateFlagsKHR -> VkDisplaySurfaceCreateFlagsKHR
>= :: VkDisplaySurfaceCreateFlagsKHR
-> VkDisplaySurfaceCreateFlagsKHR -> Bool
$c>= :: VkDisplaySurfaceCreateFlagsKHR
-> VkDisplaySurfaceCreateFlagsKHR -> Bool
> :: VkDisplaySurfaceCreateFlagsKHR
-> VkDisplaySurfaceCreateFlagsKHR -> Bool
$c> :: VkDisplaySurfaceCreateFlagsKHR
-> VkDisplaySurfaceCreateFlagsKHR -> Bool
<= :: VkDisplaySurfaceCreateFlagsKHR
-> VkDisplaySurfaceCreateFlagsKHR -> Bool
$c<= :: VkDisplaySurfaceCreateFlagsKHR
-> VkDisplaySurfaceCreateFlagsKHR -> Bool
< :: VkDisplaySurfaceCreateFlagsKHR
-> VkDisplaySurfaceCreateFlagsKHR -> Bool
$c< :: VkDisplaySurfaceCreateFlagsKHR
-> VkDisplaySurfaceCreateFlagsKHR -> Bool
compare :: VkDisplaySurfaceCreateFlagsKHR
-> VkDisplaySurfaceCreateFlagsKHR -> Ordering
$ccompare :: VkDisplaySurfaceCreateFlagsKHR
-> VkDisplaySurfaceCreateFlagsKHR -> Ordering
Ord, Int -> VkDisplaySurfaceCreateFlagsKHR
VkDisplaySurfaceCreateFlagsKHR -> Int
VkDisplaySurfaceCreateFlagsKHR -> [VkDisplaySurfaceCreateFlagsKHR]
VkDisplaySurfaceCreateFlagsKHR -> VkDisplaySurfaceCreateFlagsKHR
VkDisplaySurfaceCreateFlagsKHR
-> VkDisplaySurfaceCreateFlagsKHR
-> [VkDisplaySurfaceCreateFlagsKHR]
VkDisplaySurfaceCreateFlagsKHR
-> VkDisplaySurfaceCreateFlagsKHR
-> VkDisplaySurfaceCreateFlagsKHR
-> [VkDisplaySurfaceCreateFlagsKHR]
(VkDisplaySurfaceCreateFlagsKHR -> VkDisplaySurfaceCreateFlagsKHR)
-> (VkDisplaySurfaceCreateFlagsKHR
    -> VkDisplaySurfaceCreateFlagsKHR)
-> (Int -> VkDisplaySurfaceCreateFlagsKHR)
-> (VkDisplaySurfaceCreateFlagsKHR -> Int)
-> (VkDisplaySurfaceCreateFlagsKHR
    -> [VkDisplaySurfaceCreateFlagsKHR])
-> (VkDisplaySurfaceCreateFlagsKHR
    -> VkDisplaySurfaceCreateFlagsKHR
    -> [VkDisplaySurfaceCreateFlagsKHR])
-> (VkDisplaySurfaceCreateFlagsKHR
    -> VkDisplaySurfaceCreateFlagsKHR
    -> [VkDisplaySurfaceCreateFlagsKHR])
-> (VkDisplaySurfaceCreateFlagsKHR
    -> VkDisplaySurfaceCreateFlagsKHR
    -> VkDisplaySurfaceCreateFlagsKHR
    -> [VkDisplaySurfaceCreateFlagsKHR])
-> Enum VkDisplaySurfaceCreateFlagsKHR
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: VkDisplaySurfaceCreateFlagsKHR
-> VkDisplaySurfaceCreateFlagsKHR
-> VkDisplaySurfaceCreateFlagsKHR
-> [VkDisplaySurfaceCreateFlagsKHR]
$cenumFromThenTo :: VkDisplaySurfaceCreateFlagsKHR
-> VkDisplaySurfaceCreateFlagsKHR
-> VkDisplaySurfaceCreateFlagsKHR
-> [VkDisplaySurfaceCreateFlagsKHR]
enumFromTo :: VkDisplaySurfaceCreateFlagsKHR
-> VkDisplaySurfaceCreateFlagsKHR
-> [VkDisplaySurfaceCreateFlagsKHR]
$cenumFromTo :: VkDisplaySurfaceCreateFlagsKHR
-> VkDisplaySurfaceCreateFlagsKHR
-> [VkDisplaySurfaceCreateFlagsKHR]
enumFromThen :: VkDisplaySurfaceCreateFlagsKHR
-> VkDisplaySurfaceCreateFlagsKHR
-> [VkDisplaySurfaceCreateFlagsKHR]
$cenumFromThen :: VkDisplaySurfaceCreateFlagsKHR
-> VkDisplaySurfaceCreateFlagsKHR
-> [VkDisplaySurfaceCreateFlagsKHR]
enumFrom :: VkDisplaySurfaceCreateFlagsKHR -> [VkDisplaySurfaceCreateFlagsKHR]
$cenumFrom :: VkDisplaySurfaceCreateFlagsKHR -> [VkDisplaySurfaceCreateFlagsKHR]
fromEnum :: VkDisplaySurfaceCreateFlagsKHR -> Int
$cfromEnum :: VkDisplaySurfaceCreateFlagsKHR -> Int
toEnum :: Int -> VkDisplaySurfaceCreateFlagsKHR
$ctoEnum :: Int -> VkDisplaySurfaceCreateFlagsKHR
pred :: VkDisplaySurfaceCreateFlagsKHR -> VkDisplaySurfaceCreateFlagsKHR
$cpred :: VkDisplaySurfaceCreateFlagsKHR -> VkDisplaySurfaceCreateFlagsKHR
succ :: VkDisplaySurfaceCreateFlagsKHR -> VkDisplaySurfaceCreateFlagsKHR
$csucc :: VkDisplaySurfaceCreateFlagsKHR -> VkDisplaySurfaceCreateFlagsKHR
Enum, Eq VkDisplaySurfaceCreateFlagsKHR
VkDisplaySurfaceCreateFlagsKHR
Eq VkDisplaySurfaceCreateFlagsKHR
-> (VkDisplaySurfaceCreateFlagsKHR
    -> VkDisplaySurfaceCreateFlagsKHR
    -> VkDisplaySurfaceCreateFlagsKHR)
-> (VkDisplaySurfaceCreateFlagsKHR
    -> VkDisplaySurfaceCreateFlagsKHR
    -> VkDisplaySurfaceCreateFlagsKHR)
-> (VkDisplaySurfaceCreateFlagsKHR
    -> VkDisplaySurfaceCreateFlagsKHR
    -> VkDisplaySurfaceCreateFlagsKHR)
-> (VkDisplaySurfaceCreateFlagsKHR
    -> VkDisplaySurfaceCreateFlagsKHR)
-> (VkDisplaySurfaceCreateFlagsKHR
    -> Int -> VkDisplaySurfaceCreateFlagsKHR)
-> (VkDisplaySurfaceCreateFlagsKHR
    -> Int -> VkDisplaySurfaceCreateFlagsKHR)
-> VkDisplaySurfaceCreateFlagsKHR
-> (Int -> VkDisplaySurfaceCreateFlagsKHR)
-> (VkDisplaySurfaceCreateFlagsKHR
    -> Int -> VkDisplaySurfaceCreateFlagsKHR)
-> (VkDisplaySurfaceCreateFlagsKHR
    -> Int -> VkDisplaySurfaceCreateFlagsKHR)
-> (VkDisplaySurfaceCreateFlagsKHR
    -> Int -> VkDisplaySurfaceCreateFlagsKHR)
-> (VkDisplaySurfaceCreateFlagsKHR -> Int -> Bool)
-> (VkDisplaySurfaceCreateFlagsKHR -> Maybe Int)
-> (VkDisplaySurfaceCreateFlagsKHR -> Int)
-> (VkDisplaySurfaceCreateFlagsKHR -> Bool)
-> (VkDisplaySurfaceCreateFlagsKHR
    -> Int -> VkDisplaySurfaceCreateFlagsKHR)
-> (VkDisplaySurfaceCreateFlagsKHR
    -> Int -> VkDisplaySurfaceCreateFlagsKHR)
-> (VkDisplaySurfaceCreateFlagsKHR
    -> Int -> VkDisplaySurfaceCreateFlagsKHR)
-> (VkDisplaySurfaceCreateFlagsKHR
    -> Int -> VkDisplaySurfaceCreateFlagsKHR)
-> (VkDisplaySurfaceCreateFlagsKHR
    -> Int -> VkDisplaySurfaceCreateFlagsKHR)
-> (VkDisplaySurfaceCreateFlagsKHR
    -> Int -> VkDisplaySurfaceCreateFlagsKHR)
-> (VkDisplaySurfaceCreateFlagsKHR -> Int)
-> Bits VkDisplaySurfaceCreateFlagsKHR
Int -> VkDisplaySurfaceCreateFlagsKHR
VkDisplaySurfaceCreateFlagsKHR -> Bool
VkDisplaySurfaceCreateFlagsKHR -> Int
VkDisplaySurfaceCreateFlagsKHR -> Maybe Int
VkDisplaySurfaceCreateFlagsKHR -> VkDisplaySurfaceCreateFlagsKHR
VkDisplaySurfaceCreateFlagsKHR -> Int -> Bool
VkDisplaySurfaceCreateFlagsKHR
-> Int -> VkDisplaySurfaceCreateFlagsKHR
VkDisplaySurfaceCreateFlagsKHR
-> VkDisplaySurfaceCreateFlagsKHR -> VkDisplaySurfaceCreateFlagsKHR
forall a.
Eq a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
popCount :: VkDisplaySurfaceCreateFlagsKHR -> Int
$cpopCount :: VkDisplaySurfaceCreateFlagsKHR -> Int
rotateR :: VkDisplaySurfaceCreateFlagsKHR
-> Int -> VkDisplaySurfaceCreateFlagsKHR
$crotateR :: VkDisplaySurfaceCreateFlagsKHR
-> Int -> VkDisplaySurfaceCreateFlagsKHR
rotateL :: VkDisplaySurfaceCreateFlagsKHR
-> Int -> VkDisplaySurfaceCreateFlagsKHR
$crotateL :: VkDisplaySurfaceCreateFlagsKHR
-> Int -> VkDisplaySurfaceCreateFlagsKHR
unsafeShiftR :: VkDisplaySurfaceCreateFlagsKHR
-> Int -> VkDisplaySurfaceCreateFlagsKHR
$cunsafeShiftR :: VkDisplaySurfaceCreateFlagsKHR
-> Int -> VkDisplaySurfaceCreateFlagsKHR
shiftR :: VkDisplaySurfaceCreateFlagsKHR
-> Int -> VkDisplaySurfaceCreateFlagsKHR
$cshiftR :: VkDisplaySurfaceCreateFlagsKHR
-> Int -> VkDisplaySurfaceCreateFlagsKHR
unsafeShiftL :: VkDisplaySurfaceCreateFlagsKHR
-> Int -> VkDisplaySurfaceCreateFlagsKHR
$cunsafeShiftL :: VkDisplaySurfaceCreateFlagsKHR
-> Int -> VkDisplaySurfaceCreateFlagsKHR
shiftL :: VkDisplaySurfaceCreateFlagsKHR
-> Int -> VkDisplaySurfaceCreateFlagsKHR
$cshiftL :: VkDisplaySurfaceCreateFlagsKHR
-> Int -> VkDisplaySurfaceCreateFlagsKHR
isSigned :: VkDisplaySurfaceCreateFlagsKHR -> Bool
$cisSigned :: VkDisplaySurfaceCreateFlagsKHR -> Bool
bitSize :: VkDisplaySurfaceCreateFlagsKHR -> Int
$cbitSize :: VkDisplaySurfaceCreateFlagsKHR -> Int
bitSizeMaybe :: VkDisplaySurfaceCreateFlagsKHR -> Maybe Int
$cbitSizeMaybe :: VkDisplaySurfaceCreateFlagsKHR -> Maybe Int
testBit :: VkDisplaySurfaceCreateFlagsKHR -> Int -> Bool
$ctestBit :: VkDisplaySurfaceCreateFlagsKHR -> Int -> Bool
complementBit :: VkDisplaySurfaceCreateFlagsKHR
-> Int -> VkDisplaySurfaceCreateFlagsKHR
$ccomplementBit :: VkDisplaySurfaceCreateFlagsKHR
-> Int -> VkDisplaySurfaceCreateFlagsKHR
clearBit :: VkDisplaySurfaceCreateFlagsKHR
-> Int -> VkDisplaySurfaceCreateFlagsKHR
$cclearBit :: VkDisplaySurfaceCreateFlagsKHR
-> Int -> VkDisplaySurfaceCreateFlagsKHR
setBit :: VkDisplaySurfaceCreateFlagsKHR
-> Int -> VkDisplaySurfaceCreateFlagsKHR
$csetBit :: VkDisplaySurfaceCreateFlagsKHR
-> Int -> VkDisplaySurfaceCreateFlagsKHR
bit :: Int -> VkDisplaySurfaceCreateFlagsKHR
$cbit :: Int -> VkDisplaySurfaceCreateFlagsKHR
zeroBits :: VkDisplaySurfaceCreateFlagsKHR
$czeroBits :: VkDisplaySurfaceCreateFlagsKHR
rotate :: VkDisplaySurfaceCreateFlagsKHR
-> Int -> VkDisplaySurfaceCreateFlagsKHR
$crotate :: VkDisplaySurfaceCreateFlagsKHR
-> Int -> VkDisplaySurfaceCreateFlagsKHR
shift :: VkDisplaySurfaceCreateFlagsKHR
-> Int -> VkDisplaySurfaceCreateFlagsKHR
$cshift :: VkDisplaySurfaceCreateFlagsKHR
-> Int -> VkDisplaySurfaceCreateFlagsKHR
complement :: VkDisplaySurfaceCreateFlagsKHR -> VkDisplaySurfaceCreateFlagsKHR
$ccomplement :: VkDisplaySurfaceCreateFlagsKHR -> VkDisplaySurfaceCreateFlagsKHR
xor :: VkDisplaySurfaceCreateFlagsKHR
-> VkDisplaySurfaceCreateFlagsKHR -> VkDisplaySurfaceCreateFlagsKHR
$cxor :: VkDisplaySurfaceCreateFlagsKHR
-> VkDisplaySurfaceCreateFlagsKHR -> VkDisplaySurfaceCreateFlagsKHR
.|. :: VkDisplaySurfaceCreateFlagsKHR
-> VkDisplaySurfaceCreateFlagsKHR -> VkDisplaySurfaceCreateFlagsKHR
$c.|. :: VkDisplaySurfaceCreateFlagsKHR
-> VkDisplaySurfaceCreateFlagsKHR -> VkDisplaySurfaceCreateFlagsKHR
.&. :: VkDisplaySurfaceCreateFlagsKHR
-> VkDisplaySurfaceCreateFlagsKHR -> VkDisplaySurfaceCreateFlagsKHR
$c.&. :: VkDisplaySurfaceCreateFlagsKHR
-> VkDisplaySurfaceCreateFlagsKHR -> VkDisplaySurfaceCreateFlagsKHR
Bits, Bits VkDisplaySurfaceCreateFlagsKHR
Bits VkDisplaySurfaceCreateFlagsKHR
-> (VkDisplaySurfaceCreateFlagsKHR -> Int)
-> (VkDisplaySurfaceCreateFlagsKHR -> Int)
-> (VkDisplaySurfaceCreateFlagsKHR -> Int)
-> FiniteBits VkDisplaySurfaceCreateFlagsKHR
VkDisplaySurfaceCreateFlagsKHR -> Int
forall b.
Bits b -> (b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
countTrailingZeros :: VkDisplaySurfaceCreateFlagsKHR -> Int
$ccountTrailingZeros :: VkDisplaySurfaceCreateFlagsKHR -> Int
countLeadingZeros :: VkDisplaySurfaceCreateFlagsKHR -> Int
$ccountLeadingZeros :: VkDisplaySurfaceCreateFlagsKHR -> Int
finiteBitSize :: VkDisplaySurfaceCreateFlagsKHR -> Int
$cfiniteBitSize :: VkDisplaySurfaceCreateFlagsKHR -> Int
FiniteBits, Ptr VkDisplaySurfaceCreateFlagsKHR
-> IO VkDisplaySurfaceCreateFlagsKHR
Ptr VkDisplaySurfaceCreateFlagsKHR
-> Int -> IO VkDisplaySurfaceCreateFlagsKHR
Ptr VkDisplaySurfaceCreateFlagsKHR
-> Int -> VkDisplaySurfaceCreateFlagsKHR -> IO ()
Ptr VkDisplaySurfaceCreateFlagsKHR
-> VkDisplaySurfaceCreateFlagsKHR -> IO ()
VkDisplaySurfaceCreateFlagsKHR -> Int
(VkDisplaySurfaceCreateFlagsKHR -> Int)
-> (VkDisplaySurfaceCreateFlagsKHR -> Int)
-> (Ptr VkDisplaySurfaceCreateFlagsKHR
    -> Int -> IO VkDisplaySurfaceCreateFlagsKHR)
-> (Ptr VkDisplaySurfaceCreateFlagsKHR
    -> Int -> VkDisplaySurfaceCreateFlagsKHR -> IO ())
-> (forall b. Ptr b -> Int -> IO VkDisplaySurfaceCreateFlagsKHR)
-> (forall b.
    Ptr b -> Int -> VkDisplaySurfaceCreateFlagsKHR -> IO ())
-> (Ptr VkDisplaySurfaceCreateFlagsKHR
    -> IO VkDisplaySurfaceCreateFlagsKHR)
-> (Ptr VkDisplaySurfaceCreateFlagsKHR
    -> VkDisplaySurfaceCreateFlagsKHR -> IO ())
-> Storable VkDisplaySurfaceCreateFlagsKHR
forall b. Ptr b -> Int -> IO VkDisplaySurfaceCreateFlagsKHR
forall b. Ptr b -> Int -> VkDisplaySurfaceCreateFlagsKHR -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr VkDisplaySurfaceCreateFlagsKHR
-> VkDisplaySurfaceCreateFlagsKHR -> IO ()
$cpoke :: Ptr VkDisplaySurfaceCreateFlagsKHR
-> VkDisplaySurfaceCreateFlagsKHR -> IO ()
peek :: Ptr VkDisplaySurfaceCreateFlagsKHR
-> IO VkDisplaySurfaceCreateFlagsKHR
$cpeek :: Ptr VkDisplaySurfaceCreateFlagsKHR
-> IO VkDisplaySurfaceCreateFlagsKHR
pokeByteOff :: forall b. Ptr b -> Int -> VkDisplaySurfaceCreateFlagsKHR -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> VkDisplaySurfaceCreateFlagsKHR -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO VkDisplaySurfaceCreateFlagsKHR
$cpeekByteOff :: forall b. Ptr b -> Int -> IO VkDisplaySurfaceCreateFlagsKHR
pokeElemOff :: Ptr VkDisplaySurfaceCreateFlagsKHR
-> Int -> VkDisplaySurfaceCreateFlagsKHR -> IO ()
$cpokeElemOff :: Ptr VkDisplaySurfaceCreateFlagsKHR
-> Int -> VkDisplaySurfaceCreateFlagsKHR -> IO ()
peekElemOff :: Ptr VkDisplaySurfaceCreateFlagsKHR
-> Int -> IO VkDisplaySurfaceCreateFlagsKHR
$cpeekElemOff :: Ptr VkDisplaySurfaceCreateFlagsKHR
-> Int -> IO VkDisplaySurfaceCreateFlagsKHR
alignment :: VkDisplaySurfaceCreateFlagsKHR -> Int
$calignment :: VkDisplaySurfaceCreateFlagsKHR -> Int
sizeOf :: VkDisplaySurfaceCreateFlagsKHR -> Int
$csizeOf :: VkDisplaySurfaceCreateFlagsKHR -> Int
Storable)

instance Show VkDisplaySurfaceCreateFlagsKHR where
    {-# INLINE showsPrec #-}
    showsPrec :: Int -> VkDisplaySurfaceCreateFlagsKHR -> ShowS
showsPrec = (Int -> VkFlags -> ShowS)
-> Int -> VkDisplaySurfaceCreateFlagsKHR -> ShowS
coerce (Int -> VkFlags -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec :: Int -> VkFlags -> ShowS)

instance Read VkDisplaySurfaceCreateFlagsKHR where
    {-# INLINE readsPrec #-}
    readsPrec :: Int -> ReadS VkDisplaySurfaceCreateFlagsKHR
readsPrec = (Int -> ReadS VkFlags)
-> Int -> ReadS VkDisplaySurfaceCreateFlagsKHR
coerce (Int -> ReadS VkFlags
forall a. Read a => Int -> ReadS a
readsPrec :: Int -> ReadS VkFlags)

newtype VkEventCreateFlags = VkEventCreateFlags VkFlags
                             deriving (VkEventCreateFlags -> VkEventCreateFlags -> Bool
(VkEventCreateFlags -> VkEventCreateFlags -> Bool)
-> (VkEventCreateFlags -> VkEventCreateFlags -> Bool)
-> Eq VkEventCreateFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VkEventCreateFlags -> VkEventCreateFlags -> Bool
$c/= :: VkEventCreateFlags -> VkEventCreateFlags -> Bool
== :: VkEventCreateFlags -> VkEventCreateFlags -> Bool
$c== :: VkEventCreateFlags -> VkEventCreateFlags -> Bool
Eq, Eq VkEventCreateFlags
Eq VkEventCreateFlags
-> (VkEventCreateFlags -> VkEventCreateFlags -> Ordering)
-> (VkEventCreateFlags -> VkEventCreateFlags -> Bool)
-> (VkEventCreateFlags -> VkEventCreateFlags -> Bool)
-> (VkEventCreateFlags -> VkEventCreateFlags -> Bool)
-> (VkEventCreateFlags -> VkEventCreateFlags -> Bool)
-> (VkEventCreateFlags -> VkEventCreateFlags -> VkEventCreateFlags)
-> (VkEventCreateFlags -> VkEventCreateFlags -> VkEventCreateFlags)
-> Ord VkEventCreateFlags
VkEventCreateFlags -> VkEventCreateFlags -> Bool
VkEventCreateFlags -> VkEventCreateFlags -> Ordering
VkEventCreateFlags -> VkEventCreateFlags -> VkEventCreateFlags
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: VkEventCreateFlags -> VkEventCreateFlags -> VkEventCreateFlags
$cmin :: VkEventCreateFlags -> VkEventCreateFlags -> VkEventCreateFlags
max :: VkEventCreateFlags -> VkEventCreateFlags -> VkEventCreateFlags
$cmax :: VkEventCreateFlags -> VkEventCreateFlags -> VkEventCreateFlags
>= :: VkEventCreateFlags -> VkEventCreateFlags -> Bool
$c>= :: VkEventCreateFlags -> VkEventCreateFlags -> Bool
> :: VkEventCreateFlags -> VkEventCreateFlags -> Bool
$c> :: VkEventCreateFlags -> VkEventCreateFlags -> Bool
<= :: VkEventCreateFlags -> VkEventCreateFlags -> Bool
$c<= :: VkEventCreateFlags -> VkEventCreateFlags -> Bool
< :: VkEventCreateFlags -> VkEventCreateFlags -> Bool
$c< :: VkEventCreateFlags -> VkEventCreateFlags -> Bool
compare :: VkEventCreateFlags -> VkEventCreateFlags -> Ordering
$ccompare :: VkEventCreateFlags -> VkEventCreateFlags -> Ordering
Ord, Int -> VkEventCreateFlags
VkEventCreateFlags -> Int
VkEventCreateFlags -> [VkEventCreateFlags]
VkEventCreateFlags -> VkEventCreateFlags
VkEventCreateFlags -> VkEventCreateFlags -> [VkEventCreateFlags]
VkEventCreateFlags
-> VkEventCreateFlags -> VkEventCreateFlags -> [VkEventCreateFlags]
(VkEventCreateFlags -> VkEventCreateFlags)
-> (VkEventCreateFlags -> VkEventCreateFlags)
-> (Int -> VkEventCreateFlags)
-> (VkEventCreateFlags -> Int)
-> (VkEventCreateFlags -> [VkEventCreateFlags])
-> (VkEventCreateFlags
    -> VkEventCreateFlags -> [VkEventCreateFlags])
-> (VkEventCreateFlags
    -> VkEventCreateFlags -> [VkEventCreateFlags])
-> (VkEventCreateFlags
    -> VkEventCreateFlags
    -> VkEventCreateFlags
    -> [VkEventCreateFlags])
-> Enum VkEventCreateFlags
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: VkEventCreateFlags
-> VkEventCreateFlags -> VkEventCreateFlags -> [VkEventCreateFlags]
$cenumFromThenTo :: VkEventCreateFlags
-> VkEventCreateFlags -> VkEventCreateFlags -> [VkEventCreateFlags]
enumFromTo :: VkEventCreateFlags -> VkEventCreateFlags -> [VkEventCreateFlags]
$cenumFromTo :: VkEventCreateFlags -> VkEventCreateFlags -> [VkEventCreateFlags]
enumFromThen :: VkEventCreateFlags -> VkEventCreateFlags -> [VkEventCreateFlags]
$cenumFromThen :: VkEventCreateFlags -> VkEventCreateFlags -> [VkEventCreateFlags]
enumFrom :: VkEventCreateFlags -> [VkEventCreateFlags]
$cenumFrom :: VkEventCreateFlags -> [VkEventCreateFlags]
fromEnum :: VkEventCreateFlags -> Int
$cfromEnum :: VkEventCreateFlags -> Int
toEnum :: Int -> VkEventCreateFlags
$ctoEnum :: Int -> VkEventCreateFlags
pred :: VkEventCreateFlags -> VkEventCreateFlags
$cpred :: VkEventCreateFlags -> VkEventCreateFlags
succ :: VkEventCreateFlags -> VkEventCreateFlags
$csucc :: VkEventCreateFlags -> VkEventCreateFlags
Enum, Eq VkEventCreateFlags
VkEventCreateFlags
Eq VkEventCreateFlags
-> (VkEventCreateFlags -> VkEventCreateFlags -> VkEventCreateFlags)
-> (VkEventCreateFlags -> VkEventCreateFlags -> VkEventCreateFlags)
-> (VkEventCreateFlags -> VkEventCreateFlags -> VkEventCreateFlags)
-> (VkEventCreateFlags -> VkEventCreateFlags)
-> (VkEventCreateFlags -> Int -> VkEventCreateFlags)
-> (VkEventCreateFlags -> Int -> VkEventCreateFlags)
-> VkEventCreateFlags
-> (Int -> VkEventCreateFlags)
-> (VkEventCreateFlags -> Int -> VkEventCreateFlags)
-> (VkEventCreateFlags -> Int -> VkEventCreateFlags)
-> (VkEventCreateFlags -> Int -> VkEventCreateFlags)
-> (VkEventCreateFlags -> Int -> Bool)
-> (VkEventCreateFlags -> Maybe Int)
-> (VkEventCreateFlags -> Int)
-> (VkEventCreateFlags -> Bool)
-> (VkEventCreateFlags -> Int -> VkEventCreateFlags)
-> (VkEventCreateFlags -> Int -> VkEventCreateFlags)
-> (VkEventCreateFlags -> Int -> VkEventCreateFlags)
-> (VkEventCreateFlags -> Int -> VkEventCreateFlags)
-> (VkEventCreateFlags -> Int -> VkEventCreateFlags)
-> (VkEventCreateFlags -> Int -> VkEventCreateFlags)
-> (VkEventCreateFlags -> Int)
-> Bits VkEventCreateFlags
Int -> VkEventCreateFlags
VkEventCreateFlags -> Bool
VkEventCreateFlags -> Int
VkEventCreateFlags -> Maybe Int
VkEventCreateFlags -> VkEventCreateFlags
VkEventCreateFlags -> Int -> Bool
VkEventCreateFlags -> Int -> VkEventCreateFlags
VkEventCreateFlags -> VkEventCreateFlags -> VkEventCreateFlags
forall a.
Eq a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
popCount :: VkEventCreateFlags -> Int
$cpopCount :: VkEventCreateFlags -> Int
rotateR :: VkEventCreateFlags -> Int -> VkEventCreateFlags
$crotateR :: VkEventCreateFlags -> Int -> VkEventCreateFlags
rotateL :: VkEventCreateFlags -> Int -> VkEventCreateFlags
$crotateL :: VkEventCreateFlags -> Int -> VkEventCreateFlags
unsafeShiftR :: VkEventCreateFlags -> Int -> VkEventCreateFlags
$cunsafeShiftR :: VkEventCreateFlags -> Int -> VkEventCreateFlags
shiftR :: VkEventCreateFlags -> Int -> VkEventCreateFlags
$cshiftR :: VkEventCreateFlags -> Int -> VkEventCreateFlags
unsafeShiftL :: VkEventCreateFlags -> Int -> VkEventCreateFlags
$cunsafeShiftL :: VkEventCreateFlags -> Int -> VkEventCreateFlags
shiftL :: VkEventCreateFlags -> Int -> VkEventCreateFlags
$cshiftL :: VkEventCreateFlags -> Int -> VkEventCreateFlags
isSigned :: VkEventCreateFlags -> Bool
$cisSigned :: VkEventCreateFlags -> Bool
bitSize :: VkEventCreateFlags -> Int
$cbitSize :: VkEventCreateFlags -> Int
bitSizeMaybe :: VkEventCreateFlags -> Maybe Int
$cbitSizeMaybe :: VkEventCreateFlags -> Maybe Int
testBit :: VkEventCreateFlags -> Int -> Bool
$ctestBit :: VkEventCreateFlags -> Int -> Bool
complementBit :: VkEventCreateFlags -> Int -> VkEventCreateFlags
$ccomplementBit :: VkEventCreateFlags -> Int -> VkEventCreateFlags
clearBit :: VkEventCreateFlags -> Int -> VkEventCreateFlags
$cclearBit :: VkEventCreateFlags -> Int -> VkEventCreateFlags
setBit :: VkEventCreateFlags -> Int -> VkEventCreateFlags
$csetBit :: VkEventCreateFlags -> Int -> VkEventCreateFlags
bit :: Int -> VkEventCreateFlags
$cbit :: Int -> VkEventCreateFlags
zeroBits :: VkEventCreateFlags
$czeroBits :: VkEventCreateFlags
rotate :: VkEventCreateFlags -> Int -> VkEventCreateFlags
$crotate :: VkEventCreateFlags -> Int -> VkEventCreateFlags
shift :: VkEventCreateFlags -> Int -> VkEventCreateFlags
$cshift :: VkEventCreateFlags -> Int -> VkEventCreateFlags
complement :: VkEventCreateFlags -> VkEventCreateFlags
$ccomplement :: VkEventCreateFlags -> VkEventCreateFlags
xor :: VkEventCreateFlags -> VkEventCreateFlags -> VkEventCreateFlags
$cxor :: VkEventCreateFlags -> VkEventCreateFlags -> VkEventCreateFlags
.|. :: VkEventCreateFlags -> VkEventCreateFlags -> VkEventCreateFlags
$c.|. :: VkEventCreateFlags -> VkEventCreateFlags -> VkEventCreateFlags
.&. :: VkEventCreateFlags -> VkEventCreateFlags -> VkEventCreateFlags
$c.&. :: VkEventCreateFlags -> VkEventCreateFlags -> VkEventCreateFlags
Bits, Bits VkEventCreateFlags
Bits VkEventCreateFlags
-> (VkEventCreateFlags -> Int)
-> (VkEventCreateFlags -> Int)
-> (VkEventCreateFlags -> Int)
-> FiniteBits VkEventCreateFlags
VkEventCreateFlags -> Int
forall b.
Bits b -> (b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
countTrailingZeros :: VkEventCreateFlags -> Int
$ccountTrailingZeros :: VkEventCreateFlags -> Int
countLeadingZeros :: VkEventCreateFlags -> Int
$ccountLeadingZeros :: VkEventCreateFlags -> Int
finiteBitSize :: VkEventCreateFlags -> Int
$cfiniteBitSize :: VkEventCreateFlags -> Int
FiniteBits, Ptr VkEventCreateFlags -> IO VkEventCreateFlags
Ptr VkEventCreateFlags -> Int -> IO VkEventCreateFlags
Ptr VkEventCreateFlags -> Int -> VkEventCreateFlags -> IO ()
Ptr VkEventCreateFlags -> VkEventCreateFlags -> IO ()
VkEventCreateFlags -> Int
(VkEventCreateFlags -> Int)
-> (VkEventCreateFlags -> Int)
-> (Ptr VkEventCreateFlags -> Int -> IO VkEventCreateFlags)
-> (Ptr VkEventCreateFlags -> Int -> VkEventCreateFlags -> IO ())
-> (forall b. Ptr b -> Int -> IO VkEventCreateFlags)
-> (forall b. Ptr b -> Int -> VkEventCreateFlags -> IO ())
-> (Ptr VkEventCreateFlags -> IO VkEventCreateFlags)
-> (Ptr VkEventCreateFlags -> VkEventCreateFlags -> IO ())
-> Storable VkEventCreateFlags
forall b. Ptr b -> Int -> IO VkEventCreateFlags
forall b. Ptr b -> Int -> VkEventCreateFlags -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr VkEventCreateFlags -> VkEventCreateFlags -> IO ()
$cpoke :: Ptr VkEventCreateFlags -> VkEventCreateFlags -> IO ()
peek :: Ptr VkEventCreateFlags -> IO VkEventCreateFlags
$cpeek :: Ptr VkEventCreateFlags -> IO VkEventCreateFlags
pokeByteOff :: forall b. Ptr b -> Int -> VkEventCreateFlags -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> VkEventCreateFlags -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO VkEventCreateFlags
$cpeekByteOff :: forall b. Ptr b -> Int -> IO VkEventCreateFlags
pokeElemOff :: Ptr VkEventCreateFlags -> Int -> VkEventCreateFlags -> IO ()
$cpokeElemOff :: Ptr VkEventCreateFlags -> Int -> VkEventCreateFlags -> IO ()
peekElemOff :: Ptr VkEventCreateFlags -> Int -> IO VkEventCreateFlags
$cpeekElemOff :: Ptr VkEventCreateFlags -> Int -> IO VkEventCreateFlags
alignment :: VkEventCreateFlags -> Int
$calignment :: VkEventCreateFlags -> Int
sizeOf :: VkEventCreateFlags -> Int
$csizeOf :: VkEventCreateFlags -> Int
Storable)

instance Show VkEventCreateFlags where
    {-# INLINE showsPrec #-}
    showsPrec :: Int -> VkEventCreateFlags -> ShowS
showsPrec = (Int -> VkFlags -> ShowS) -> Int -> VkEventCreateFlags -> ShowS
coerce (Int -> VkFlags -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec :: Int -> VkFlags -> ShowS)

instance Read VkEventCreateFlags where
    {-# INLINE readsPrec #-}
    readsPrec :: Int -> ReadS VkEventCreateFlags
readsPrec = (Int -> ReadS VkFlags) -> Int -> ReadS VkEventCreateFlags
coerce (Int -> ReadS VkFlags
forall a. Read a => Int -> ReadS a
readsPrec :: Int -> ReadS VkFlags)

newtype VkExternalFenceFeatureFlagsKHR = VkExternalFenceFeatureFlagsKHR VkFlags
                                         deriving (VkExternalFenceFeatureFlagsKHR
-> VkExternalFenceFeatureFlagsKHR -> Bool
(VkExternalFenceFeatureFlagsKHR
 -> VkExternalFenceFeatureFlagsKHR -> Bool)
-> (VkExternalFenceFeatureFlagsKHR
    -> VkExternalFenceFeatureFlagsKHR -> Bool)
-> Eq VkExternalFenceFeatureFlagsKHR
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VkExternalFenceFeatureFlagsKHR
-> VkExternalFenceFeatureFlagsKHR -> Bool
$c/= :: VkExternalFenceFeatureFlagsKHR
-> VkExternalFenceFeatureFlagsKHR -> Bool
== :: VkExternalFenceFeatureFlagsKHR
-> VkExternalFenceFeatureFlagsKHR -> Bool
$c== :: VkExternalFenceFeatureFlagsKHR
-> VkExternalFenceFeatureFlagsKHR -> Bool
Eq, Eq VkExternalFenceFeatureFlagsKHR
Eq VkExternalFenceFeatureFlagsKHR
-> (VkExternalFenceFeatureFlagsKHR
    -> VkExternalFenceFeatureFlagsKHR -> Ordering)
-> (VkExternalFenceFeatureFlagsKHR
    -> VkExternalFenceFeatureFlagsKHR -> Bool)
-> (VkExternalFenceFeatureFlagsKHR
    -> VkExternalFenceFeatureFlagsKHR -> Bool)
-> (VkExternalFenceFeatureFlagsKHR
    -> VkExternalFenceFeatureFlagsKHR -> Bool)
-> (VkExternalFenceFeatureFlagsKHR
    -> VkExternalFenceFeatureFlagsKHR -> Bool)
-> (VkExternalFenceFeatureFlagsKHR
    -> VkExternalFenceFeatureFlagsKHR
    -> VkExternalFenceFeatureFlagsKHR)
-> (VkExternalFenceFeatureFlagsKHR
    -> VkExternalFenceFeatureFlagsKHR
    -> VkExternalFenceFeatureFlagsKHR)
-> Ord VkExternalFenceFeatureFlagsKHR
VkExternalFenceFeatureFlagsKHR
-> VkExternalFenceFeatureFlagsKHR -> Bool
VkExternalFenceFeatureFlagsKHR
-> VkExternalFenceFeatureFlagsKHR -> Ordering
VkExternalFenceFeatureFlagsKHR
-> VkExternalFenceFeatureFlagsKHR -> VkExternalFenceFeatureFlagsKHR
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: VkExternalFenceFeatureFlagsKHR
-> VkExternalFenceFeatureFlagsKHR -> VkExternalFenceFeatureFlagsKHR
$cmin :: VkExternalFenceFeatureFlagsKHR
-> VkExternalFenceFeatureFlagsKHR -> VkExternalFenceFeatureFlagsKHR
max :: VkExternalFenceFeatureFlagsKHR
-> VkExternalFenceFeatureFlagsKHR -> VkExternalFenceFeatureFlagsKHR
$cmax :: VkExternalFenceFeatureFlagsKHR
-> VkExternalFenceFeatureFlagsKHR -> VkExternalFenceFeatureFlagsKHR
>= :: VkExternalFenceFeatureFlagsKHR
-> VkExternalFenceFeatureFlagsKHR -> Bool
$c>= :: VkExternalFenceFeatureFlagsKHR
-> VkExternalFenceFeatureFlagsKHR -> Bool
> :: VkExternalFenceFeatureFlagsKHR
-> VkExternalFenceFeatureFlagsKHR -> Bool
$c> :: VkExternalFenceFeatureFlagsKHR
-> VkExternalFenceFeatureFlagsKHR -> Bool
<= :: VkExternalFenceFeatureFlagsKHR
-> VkExternalFenceFeatureFlagsKHR -> Bool
$c<= :: VkExternalFenceFeatureFlagsKHR
-> VkExternalFenceFeatureFlagsKHR -> Bool
< :: VkExternalFenceFeatureFlagsKHR
-> VkExternalFenceFeatureFlagsKHR -> Bool
$c< :: VkExternalFenceFeatureFlagsKHR
-> VkExternalFenceFeatureFlagsKHR -> Bool
compare :: VkExternalFenceFeatureFlagsKHR
-> VkExternalFenceFeatureFlagsKHR -> Ordering
$ccompare :: VkExternalFenceFeatureFlagsKHR
-> VkExternalFenceFeatureFlagsKHR -> Ordering
Ord, Int -> VkExternalFenceFeatureFlagsKHR
VkExternalFenceFeatureFlagsKHR -> Int
VkExternalFenceFeatureFlagsKHR -> [VkExternalFenceFeatureFlagsKHR]
VkExternalFenceFeatureFlagsKHR -> VkExternalFenceFeatureFlagsKHR
VkExternalFenceFeatureFlagsKHR
-> VkExternalFenceFeatureFlagsKHR
-> [VkExternalFenceFeatureFlagsKHR]
VkExternalFenceFeatureFlagsKHR
-> VkExternalFenceFeatureFlagsKHR
-> VkExternalFenceFeatureFlagsKHR
-> [VkExternalFenceFeatureFlagsKHR]
(VkExternalFenceFeatureFlagsKHR -> VkExternalFenceFeatureFlagsKHR)
-> (VkExternalFenceFeatureFlagsKHR
    -> VkExternalFenceFeatureFlagsKHR)
-> (Int -> VkExternalFenceFeatureFlagsKHR)
-> (VkExternalFenceFeatureFlagsKHR -> Int)
-> (VkExternalFenceFeatureFlagsKHR
    -> [VkExternalFenceFeatureFlagsKHR])
-> (VkExternalFenceFeatureFlagsKHR
    -> VkExternalFenceFeatureFlagsKHR
    -> [VkExternalFenceFeatureFlagsKHR])
-> (VkExternalFenceFeatureFlagsKHR
    -> VkExternalFenceFeatureFlagsKHR
    -> [VkExternalFenceFeatureFlagsKHR])
-> (VkExternalFenceFeatureFlagsKHR
    -> VkExternalFenceFeatureFlagsKHR
    -> VkExternalFenceFeatureFlagsKHR
    -> [VkExternalFenceFeatureFlagsKHR])
-> Enum VkExternalFenceFeatureFlagsKHR
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: VkExternalFenceFeatureFlagsKHR
-> VkExternalFenceFeatureFlagsKHR
-> VkExternalFenceFeatureFlagsKHR
-> [VkExternalFenceFeatureFlagsKHR]
$cenumFromThenTo :: VkExternalFenceFeatureFlagsKHR
-> VkExternalFenceFeatureFlagsKHR
-> VkExternalFenceFeatureFlagsKHR
-> [VkExternalFenceFeatureFlagsKHR]
enumFromTo :: VkExternalFenceFeatureFlagsKHR
-> VkExternalFenceFeatureFlagsKHR
-> [VkExternalFenceFeatureFlagsKHR]
$cenumFromTo :: VkExternalFenceFeatureFlagsKHR
-> VkExternalFenceFeatureFlagsKHR
-> [VkExternalFenceFeatureFlagsKHR]
enumFromThen :: VkExternalFenceFeatureFlagsKHR
-> VkExternalFenceFeatureFlagsKHR
-> [VkExternalFenceFeatureFlagsKHR]
$cenumFromThen :: VkExternalFenceFeatureFlagsKHR
-> VkExternalFenceFeatureFlagsKHR
-> [VkExternalFenceFeatureFlagsKHR]
enumFrom :: VkExternalFenceFeatureFlagsKHR -> [VkExternalFenceFeatureFlagsKHR]
$cenumFrom :: VkExternalFenceFeatureFlagsKHR -> [VkExternalFenceFeatureFlagsKHR]
fromEnum :: VkExternalFenceFeatureFlagsKHR -> Int
$cfromEnum :: VkExternalFenceFeatureFlagsKHR -> Int
toEnum :: Int -> VkExternalFenceFeatureFlagsKHR
$ctoEnum :: Int -> VkExternalFenceFeatureFlagsKHR
pred :: VkExternalFenceFeatureFlagsKHR -> VkExternalFenceFeatureFlagsKHR
$cpred :: VkExternalFenceFeatureFlagsKHR -> VkExternalFenceFeatureFlagsKHR
succ :: VkExternalFenceFeatureFlagsKHR -> VkExternalFenceFeatureFlagsKHR
$csucc :: VkExternalFenceFeatureFlagsKHR -> VkExternalFenceFeatureFlagsKHR
Enum, Eq VkExternalFenceFeatureFlagsKHR
VkExternalFenceFeatureFlagsKHR
Eq VkExternalFenceFeatureFlagsKHR
-> (VkExternalFenceFeatureFlagsKHR
    -> VkExternalFenceFeatureFlagsKHR
    -> VkExternalFenceFeatureFlagsKHR)
-> (VkExternalFenceFeatureFlagsKHR
    -> VkExternalFenceFeatureFlagsKHR
    -> VkExternalFenceFeatureFlagsKHR)
-> (VkExternalFenceFeatureFlagsKHR
    -> VkExternalFenceFeatureFlagsKHR
    -> VkExternalFenceFeatureFlagsKHR)
-> (VkExternalFenceFeatureFlagsKHR
    -> VkExternalFenceFeatureFlagsKHR)
-> (VkExternalFenceFeatureFlagsKHR
    -> Int -> VkExternalFenceFeatureFlagsKHR)
-> (VkExternalFenceFeatureFlagsKHR
    -> Int -> VkExternalFenceFeatureFlagsKHR)
-> VkExternalFenceFeatureFlagsKHR
-> (Int -> VkExternalFenceFeatureFlagsKHR)
-> (VkExternalFenceFeatureFlagsKHR
    -> Int -> VkExternalFenceFeatureFlagsKHR)
-> (VkExternalFenceFeatureFlagsKHR
    -> Int -> VkExternalFenceFeatureFlagsKHR)
-> (VkExternalFenceFeatureFlagsKHR
    -> Int -> VkExternalFenceFeatureFlagsKHR)
-> (VkExternalFenceFeatureFlagsKHR -> Int -> Bool)
-> (VkExternalFenceFeatureFlagsKHR -> Maybe Int)
-> (VkExternalFenceFeatureFlagsKHR -> Int)
-> (VkExternalFenceFeatureFlagsKHR -> Bool)
-> (VkExternalFenceFeatureFlagsKHR
    -> Int -> VkExternalFenceFeatureFlagsKHR)
-> (VkExternalFenceFeatureFlagsKHR
    -> Int -> VkExternalFenceFeatureFlagsKHR)
-> (VkExternalFenceFeatureFlagsKHR
    -> Int -> VkExternalFenceFeatureFlagsKHR)
-> (VkExternalFenceFeatureFlagsKHR
    -> Int -> VkExternalFenceFeatureFlagsKHR)
-> (VkExternalFenceFeatureFlagsKHR
    -> Int -> VkExternalFenceFeatureFlagsKHR)
-> (VkExternalFenceFeatureFlagsKHR
    -> Int -> VkExternalFenceFeatureFlagsKHR)
-> (VkExternalFenceFeatureFlagsKHR -> Int)
-> Bits VkExternalFenceFeatureFlagsKHR
Int -> VkExternalFenceFeatureFlagsKHR
VkExternalFenceFeatureFlagsKHR -> Bool
VkExternalFenceFeatureFlagsKHR -> Int
VkExternalFenceFeatureFlagsKHR -> Maybe Int
VkExternalFenceFeatureFlagsKHR -> VkExternalFenceFeatureFlagsKHR
VkExternalFenceFeatureFlagsKHR -> Int -> Bool
VkExternalFenceFeatureFlagsKHR
-> Int -> VkExternalFenceFeatureFlagsKHR
VkExternalFenceFeatureFlagsKHR
-> VkExternalFenceFeatureFlagsKHR -> VkExternalFenceFeatureFlagsKHR
forall a.
Eq a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
popCount :: VkExternalFenceFeatureFlagsKHR -> Int
$cpopCount :: VkExternalFenceFeatureFlagsKHR -> Int
rotateR :: VkExternalFenceFeatureFlagsKHR
-> Int -> VkExternalFenceFeatureFlagsKHR
$crotateR :: VkExternalFenceFeatureFlagsKHR
-> Int -> VkExternalFenceFeatureFlagsKHR
rotateL :: VkExternalFenceFeatureFlagsKHR
-> Int -> VkExternalFenceFeatureFlagsKHR
$crotateL :: VkExternalFenceFeatureFlagsKHR
-> Int -> VkExternalFenceFeatureFlagsKHR
unsafeShiftR :: VkExternalFenceFeatureFlagsKHR
-> Int -> VkExternalFenceFeatureFlagsKHR
$cunsafeShiftR :: VkExternalFenceFeatureFlagsKHR
-> Int -> VkExternalFenceFeatureFlagsKHR
shiftR :: VkExternalFenceFeatureFlagsKHR
-> Int -> VkExternalFenceFeatureFlagsKHR
$cshiftR :: VkExternalFenceFeatureFlagsKHR
-> Int -> VkExternalFenceFeatureFlagsKHR
unsafeShiftL :: VkExternalFenceFeatureFlagsKHR
-> Int -> VkExternalFenceFeatureFlagsKHR
$cunsafeShiftL :: VkExternalFenceFeatureFlagsKHR
-> Int -> VkExternalFenceFeatureFlagsKHR
shiftL :: VkExternalFenceFeatureFlagsKHR
-> Int -> VkExternalFenceFeatureFlagsKHR
$cshiftL :: VkExternalFenceFeatureFlagsKHR
-> Int -> VkExternalFenceFeatureFlagsKHR
isSigned :: VkExternalFenceFeatureFlagsKHR -> Bool
$cisSigned :: VkExternalFenceFeatureFlagsKHR -> Bool
bitSize :: VkExternalFenceFeatureFlagsKHR -> Int
$cbitSize :: VkExternalFenceFeatureFlagsKHR -> Int
bitSizeMaybe :: VkExternalFenceFeatureFlagsKHR -> Maybe Int
$cbitSizeMaybe :: VkExternalFenceFeatureFlagsKHR -> Maybe Int
testBit :: VkExternalFenceFeatureFlagsKHR -> Int -> Bool
$ctestBit :: VkExternalFenceFeatureFlagsKHR -> Int -> Bool
complementBit :: VkExternalFenceFeatureFlagsKHR
-> Int -> VkExternalFenceFeatureFlagsKHR
$ccomplementBit :: VkExternalFenceFeatureFlagsKHR
-> Int -> VkExternalFenceFeatureFlagsKHR
clearBit :: VkExternalFenceFeatureFlagsKHR
-> Int -> VkExternalFenceFeatureFlagsKHR
$cclearBit :: VkExternalFenceFeatureFlagsKHR
-> Int -> VkExternalFenceFeatureFlagsKHR
setBit :: VkExternalFenceFeatureFlagsKHR
-> Int -> VkExternalFenceFeatureFlagsKHR
$csetBit :: VkExternalFenceFeatureFlagsKHR
-> Int -> VkExternalFenceFeatureFlagsKHR
bit :: Int -> VkExternalFenceFeatureFlagsKHR
$cbit :: Int -> VkExternalFenceFeatureFlagsKHR
zeroBits :: VkExternalFenceFeatureFlagsKHR
$czeroBits :: VkExternalFenceFeatureFlagsKHR
rotate :: VkExternalFenceFeatureFlagsKHR
-> Int -> VkExternalFenceFeatureFlagsKHR
$crotate :: VkExternalFenceFeatureFlagsKHR
-> Int -> VkExternalFenceFeatureFlagsKHR
shift :: VkExternalFenceFeatureFlagsKHR
-> Int -> VkExternalFenceFeatureFlagsKHR
$cshift :: VkExternalFenceFeatureFlagsKHR
-> Int -> VkExternalFenceFeatureFlagsKHR
complement :: VkExternalFenceFeatureFlagsKHR -> VkExternalFenceFeatureFlagsKHR
$ccomplement :: VkExternalFenceFeatureFlagsKHR -> VkExternalFenceFeatureFlagsKHR
xor :: VkExternalFenceFeatureFlagsKHR
-> VkExternalFenceFeatureFlagsKHR -> VkExternalFenceFeatureFlagsKHR
$cxor :: VkExternalFenceFeatureFlagsKHR
-> VkExternalFenceFeatureFlagsKHR -> VkExternalFenceFeatureFlagsKHR
.|. :: VkExternalFenceFeatureFlagsKHR
-> VkExternalFenceFeatureFlagsKHR -> VkExternalFenceFeatureFlagsKHR
$c.|. :: VkExternalFenceFeatureFlagsKHR
-> VkExternalFenceFeatureFlagsKHR -> VkExternalFenceFeatureFlagsKHR
.&. :: VkExternalFenceFeatureFlagsKHR
-> VkExternalFenceFeatureFlagsKHR -> VkExternalFenceFeatureFlagsKHR
$c.&. :: VkExternalFenceFeatureFlagsKHR
-> VkExternalFenceFeatureFlagsKHR -> VkExternalFenceFeatureFlagsKHR
Bits, Bits VkExternalFenceFeatureFlagsKHR
Bits VkExternalFenceFeatureFlagsKHR
-> (VkExternalFenceFeatureFlagsKHR -> Int)
-> (VkExternalFenceFeatureFlagsKHR -> Int)
-> (VkExternalFenceFeatureFlagsKHR -> Int)
-> FiniteBits VkExternalFenceFeatureFlagsKHR
VkExternalFenceFeatureFlagsKHR -> Int
forall b.
Bits b -> (b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
countTrailingZeros :: VkExternalFenceFeatureFlagsKHR -> Int
$ccountTrailingZeros :: VkExternalFenceFeatureFlagsKHR -> Int
countLeadingZeros :: VkExternalFenceFeatureFlagsKHR -> Int
$ccountLeadingZeros :: VkExternalFenceFeatureFlagsKHR -> Int
finiteBitSize :: VkExternalFenceFeatureFlagsKHR -> Int
$cfiniteBitSize :: VkExternalFenceFeatureFlagsKHR -> Int
FiniteBits, Ptr VkExternalFenceFeatureFlagsKHR
-> IO VkExternalFenceFeatureFlagsKHR
Ptr VkExternalFenceFeatureFlagsKHR
-> Int -> IO VkExternalFenceFeatureFlagsKHR
Ptr VkExternalFenceFeatureFlagsKHR
-> Int -> VkExternalFenceFeatureFlagsKHR -> IO ()
Ptr VkExternalFenceFeatureFlagsKHR
-> VkExternalFenceFeatureFlagsKHR -> IO ()
VkExternalFenceFeatureFlagsKHR -> Int
(VkExternalFenceFeatureFlagsKHR -> Int)
-> (VkExternalFenceFeatureFlagsKHR -> Int)
-> (Ptr VkExternalFenceFeatureFlagsKHR
    -> Int -> IO VkExternalFenceFeatureFlagsKHR)
-> (Ptr VkExternalFenceFeatureFlagsKHR
    -> Int -> VkExternalFenceFeatureFlagsKHR -> IO ())
-> (forall b. Ptr b -> Int -> IO VkExternalFenceFeatureFlagsKHR)
-> (forall b.
    Ptr b -> Int -> VkExternalFenceFeatureFlagsKHR -> IO ())
-> (Ptr VkExternalFenceFeatureFlagsKHR
    -> IO VkExternalFenceFeatureFlagsKHR)
-> (Ptr VkExternalFenceFeatureFlagsKHR
    -> VkExternalFenceFeatureFlagsKHR -> IO ())
-> Storable VkExternalFenceFeatureFlagsKHR
forall b. Ptr b -> Int -> IO VkExternalFenceFeatureFlagsKHR
forall b. Ptr b -> Int -> VkExternalFenceFeatureFlagsKHR -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr VkExternalFenceFeatureFlagsKHR
-> VkExternalFenceFeatureFlagsKHR -> IO ()
$cpoke :: Ptr VkExternalFenceFeatureFlagsKHR
-> VkExternalFenceFeatureFlagsKHR -> IO ()
peek :: Ptr VkExternalFenceFeatureFlagsKHR
-> IO VkExternalFenceFeatureFlagsKHR
$cpeek :: Ptr VkExternalFenceFeatureFlagsKHR
-> IO VkExternalFenceFeatureFlagsKHR
pokeByteOff :: forall b. Ptr b -> Int -> VkExternalFenceFeatureFlagsKHR -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> VkExternalFenceFeatureFlagsKHR -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO VkExternalFenceFeatureFlagsKHR
$cpeekByteOff :: forall b. Ptr b -> Int -> IO VkExternalFenceFeatureFlagsKHR
pokeElemOff :: Ptr VkExternalFenceFeatureFlagsKHR
-> Int -> VkExternalFenceFeatureFlagsKHR -> IO ()
$cpokeElemOff :: Ptr VkExternalFenceFeatureFlagsKHR
-> Int -> VkExternalFenceFeatureFlagsKHR -> IO ()
peekElemOff :: Ptr VkExternalFenceFeatureFlagsKHR
-> Int -> IO VkExternalFenceFeatureFlagsKHR
$cpeekElemOff :: Ptr VkExternalFenceFeatureFlagsKHR
-> Int -> IO VkExternalFenceFeatureFlagsKHR
alignment :: VkExternalFenceFeatureFlagsKHR -> Int
$calignment :: VkExternalFenceFeatureFlagsKHR -> Int
sizeOf :: VkExternalFenceFeatureFlagsKHR -> Int
$csizeOf :: VkExternalFenceFeatureFlagsKHR -> Int
Storable)

instance Show VkExternalFenceFeatureFlagsKHR where
    {-# INLINE showsPrec #-}
    showsPrec :: Int -> VkExternalFenceFeatureFlagsKHR -> ShowS
showsPrec = (Int -> VkFlags -> ShowS)
-> Int -> VkExternalFenceFeatureFlagsKHR -> ShowS
coerce (Int -> VkFlags -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec :: Int -> VkFlags -> ShowS)

instance Read VkExternalFenceFeatureFlagsKHR where
    {-# INLINE readsPrec #-}
    readsPrec :: Int -> ReadS VkExternalFenceFeatureFlagsKHR
readsPrec = (Int -> ReadS VkFlags)
-> Int -> ReadS VkExternalFenceFeatureFlagsKHR
coerce (Int -> ReadS VkFlags
forall a. Read a => Int -> ReadS a
readsPrec :: Int -> ReadS VkFlags)

newtype VkExternalFenceHandleTypeFlagsKHR = VkExternalFenceHandleTypeFlagsKHR VkFlags
                                            deriving (VkExternalFenceHandleTypeFlagsKHR
-> VkExternalFenceHandleTypeFlagsKHR -> Bool
(VkExternalFenceHandleTypeFlagsKHR
 -> VkExternalFenceHandleTypeFlagsKHR -> Bool)
-> (VkExternalFenceHandleTypeFlagsKHR
    -> VkExternalFenceHandleTypeFlagsKHR -> Bool)
-> Eq VkExternalFenceHandleTypeFlagsKHR
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VkExternalFenceHandleTypeFlagsKHR
-> VkExternalFenceHandleTypeFlagsKHR -> Bool
$c/= :: VkExternalFenceHandleTypeFlagsKHR
-> VkExternalFenceHandleTypeFlagsKHR -> Bool
== :: VkExternalFenceHandleTypeFlagsKHR
-> VkExternalFenceHandleTypeFlagsKHR -> Bool
$c== :: VkExternalFenceHandleTypeFlagsKHR
-> VkExternalFenceHandleTypeFlagsKHR -> Bool
Eq, Eq VkExternalFenceHandleTypeFlagsKHR
Eq VkExternalFenceHandleTypeFlagsKHR
-> (VkExternalFenceHandleTypeFlagsKHR
    -> VkExternalFenceHandleTypeFlagsKHR -> Ordering)
-> (VkExternalFenceHandleTypeFlagsKHR
    -> VkExternalFenceHandleTypeFlagsKHR -> Bool)
-> (VkExternalFenceHandleTypeFlagsKHR
    -> VkExternalFenceHandleTypeFlagsKHR -> Bool)
-> (VkExternalFenceHandleTypeFlagsKHR
    -> VkExternalFenceHandleTypeFlagsKHR -> Bool)
-> (VkExternalFenceHandleTypeFlagsKHR
    -> VkExternalFenceHandleTypeFlagsKHR -> Bool)
-> (VkExternalFenceHandleTypeFlagsKHR
    -> VkExternalFenceHandleTypeFlagsKHR
    -> VkExternalFenceHandleTypeFlagsKHR)
-> (VkExternalFenceHandleTypeFlagsKHR
    -> VkExternalFenceHandleTypeFlagsKHR
    -> VkExternalFenceHandleTypeFlagsKHR)
-> Ord VkExternalFenceHandleTypeFlagsKHR
VkExternalFenceHandleTypeFlagsKHR
-> VkExternalFenceHandleTypeFlagsKHR -> Bool
VkExternalFenceHandleTypeFlagsKHR
-> VkExternalFenceHandleTypeFlagsKHR -> Ordering
VkExternalFenceHandleTypeFlagsKHR
-> VkExternalFenceHandleTypeFlagsKHR
-> VkExternalFenceHandleTypeFlagsKHR
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: VkExternalFenceHandleTypeFlagsKHR
-> VkExternalFenceHandleTypeFlagsKHR
-> VkExternalFenceHandleTypeFlagsKHR
$cmin :: VkExternalFenceHandleTypeFlagsKHR
-> VkExternalFenceHandleTypeFlagsKHR
-> VkExternalFenceHandleTypeFlagsKHR
max :: VkExternalFenceHandleTypeFlagsKHR
-> VkExternalFenceHandleTypeFlagsKHR
-> VkExternalFenceHandleTypeFlagsKHR
$cmax :: VkExternalFenceHandleTypeFlagsKHR
-> VkExternalFenceHandleTypeFlagsKHR
-> VkExternalFenceHandleTypeFlagsKHR
>= :: VkExternalFenceHandleTypeFlagsKHR
-> VkExternalFenceHandleTypeFlagsKHR -> Bool
$c>= :: VkExternalFenceHandleTypeFlagsKHR
-> VkExternalFenceHandleTypeFlagsKHR -> Bool
> :: VkExternalFenceHandleTypeFlagsKHR
-> VkExternalFenceHandleTypeFlagsKHR -> Bool
$c> :: VkExternalFenceHandleTypeFlagsKHR
-> VkExternalFenceHandleTypeFlagsKHR -> Bool
<= :: VkExternalFenceHandleTypeFlagsKHR
-> VkExternalFenceHandleTypeFlagsKHR -> Bool
$c<= :: VkExternalFenceHandleTypeFlagsKHR
-> VkExternalFenceHandleTypeFlagsKHR -> Bool
< :: VkExternalFenceHandleTypeFlagsKHR
-> VkExternalFenceHandleTypeFlagsKHR -> Bool
$c< :: VkExternalFenceHandleTypeFlagsKHR
-> VkExternalFenceHandleTypeFlagsKHR -> Bool
compare :: VkExternalFenceHandleTypeFlagsKHR
-> VkExternalFenceHandleTypeFlagsKHR -> Ordering
$ccompare :: VkExternalFenceHandleTypeFlagsKHR
-> VkExternalFenceHandleTypeFlagsKHR -> Ordering
Ord, Int -> VkExternalFenceHandleTypeFlagsKHR
VkExternalFenceHandleTypeFlagsKHR -> Int
VkExternalFenceHandleTypeFlagsKHR
-> [VkExternalFenceHandleTypeFlagsKHR]
VkExternalFenceHandleTypeFlagsKHR
-> VkExternalFenceHandleTypeFlagsKHR
VkExternalFenceHandleTypeFlagsKHR
-> VkExternalFenceHandleTypeFlagsKHR
-> [VkExternalFenceHandleTypeFlagsKHR]
VkExternalFenceHandleTypeFlagsKHR
-> VkExternalFenceHandleTypeFlagsKHR
-> VkExternalFenceHandleTypeFlagsKHR
-> [VkExternalFenceHandleTypeFlagsKHR]
(VkExternalFenceHandleTypeFlagsKHR
 -> VkExternalFenceHandleTypeFlagsKHR)
-> (VkExternalFenceHandleTypeFlagsKHR
    -> VkExternalFenceHandleTypeFlagsKHR)
-> (Int -> VkExternalFenceHandleTypeFlagsKHR)
-> (VkExternalFenceHandleTypeFlagsKHR -> Int)
-> (VkExternalFenceHandleTypeFlagsKHR
    -> [VkExternalFenceHandleTypeFlagsKHR])
-> (VkExternalFenceHandleTypeFlagsKHR
    -> VkExternalFenceHandleTypeFlagsKHR
    -> [VkExternalFenceHandleTypeFlagsKHR])
-> (VkExternalFenceHandleTypeFlagsKHR
    -> VkExternalFenceHandleTypeFlagsKHR
    -> [VkExternalFenceHandleTypeFlagsKHR])
-> (VkExternalFenceHandleTypeFlagsKHR
    -> VkExternalFenceHandleTypeFlagsKHR
    -> VkExternalFenceHandleTypeFlagsKHR
    -> [VkExternalFenceHandleTypeFlagsKHR])
-> Enum VkExternalFenceHandleTypeFlagsKHR
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: VkExternalFenceHandleTypeFlagsKHR
-> VkExternalFenceHandleTypeFlagsKHR
-> VkExternalFenceHandleTypeFlagsKHR
-> [VkExternalFenceHandleTypeFlagsKHR]
$cenumFromThenTo :: VkExternalFenceHandleTypeFlagsKHR
-> VkExternalFenceHandleTypeFlagsKHR
-> VkExternalFenceHandleTypeFlagsKHR
-> [VkExternalFenceHandleTypeFlagsKHR]
enumFromTo :: VkExternalFenceHandleTypeFlagsKHR
-> VkExternalFenceHandleTypeFlagsKHR
-> [VkExternalFenceHandleTypeFlagsKHR]
$cenumFromTo :: VkExternalFenceHandleTypeFlagsKHR
-> VkExternalFenceHandleTypeFlagsKHR
-> [VkExternalFenceHandleTypeFlagsKHR]
enumFromThen :: VkExternalFenceHandleTypeFlagsKHR
-> VkExternalFenceHandleTypeFlagsKHR
-> [VkExternalFenceHandleTypeFlagsKHR]
$cenumFromThen :: VkExternalFenceHandleTypeFlagsKHR
-> VkExternalFenceHandleTypeFlagsKHR
-> [VkExternalFenceHandleTypeFlagsKHR]
enumFrom :: VkExternalFenceHandleTypeFlagsKHR
-> [VkExternalFenceHandleTypeFlagsKHR]
$cenumFrom :: VkExternalFenceHandleTypeFlagsKHR
-> [VkExternalFenceHandleTypeFlagsKHR]
fromEnum :: VkExternalFenceHandleTypeFlagsKHR -> Int
$cfromEnum :: VkExternalFenceHandleTypeFlagsKHR -> Int
toEnum :: Int -> VkExternalFenceHandleTypeFlagsKHR
$ctoEnum :: Int -> VkExternalFenceHandleTypeFlagsKHR
pred :: VkExternalFenceHandleTypeFlagsKHR
-> VkExternalFenceHandleTypeFlagsKHR
$cpred :: VkExternalFenceHandleTypeFlagsKHR
-> VkExternalFenceHandleTypeFlagsKHR
succ :: VkExternalFenceHandleTypeFlagsKHR
-> VkExternalFenceHandleTypeFlagsKHR
$csucc :: VkExternalFenceHandleTypeFlagsKHR
-> VkExternalFenceHandleTypeFlagsKHR
Enum, Eq VkExternalFenceHandleTypeFlagsKHR
VkExternalFenceHandleTypeFlagsKHR
Eq VkExternalFenceHandleTypeFlagsKHR
-> (VkExternalFenceHandleTypeFlagsKHR
    -> VkExternalFenceHandleTypeFlagsKHR
    -> VkExternalFenceHandleTypeFlagsKHR)
-> (VkExternalFenceHandleTypeFlagsKHR
    -> VkExternalFenceHandleTypeFlagsKHR
    -> VkExternalFenceHandleTypeFlagsKHR)
-> (VkExternalFenceHandleTypeFlagsKHR
    -> VkExternalFenceHandleTypeFlagsKHR
    -> VkExternalFenceHandleTypeFlagsKHR)
-> (VkExternalFenceHandleTypeFlagsKHR
    -> VkExternalFenceHandleTypeFlagsKHR)
-> (VkExternalFenceHandleTypeFlagsKHR
    -> Int -> VkExternalFenceHandleTypeFlagsKHR)
-> (VkExternalFenceHandleTypeFlagsKHR
    -> Int -> VkExternalFenceHandleTypeFlagsKHR)
-> VkExternalFenceHandleTypeFlagsKHR
-> (Int -> VkExternalFenceHandleTypeFlagsKHR)
-> (VkExternalFenceHandleTypeFlagsKHR
    -> Int -> VkExternalFenceHandleTypeFlagsKHR)
-> (VkExternalFenceHandleTypeFlagsKHR
    -> Int -> VkExternalFenceHandleTypeFlagsKHR)
-> (VkExternalFenceHandleTypeFlagsKHR
    -> Int -> VkExternalFenceHandleTypeFlagsKHR)
-> (VkExternalFenceHandleTypeFlagsKHR -> Int -> Bool)
-> (VkExternalFenceHandleTypeFlagsKHR -> Maybe Int)
-> (VkExternalFenceHandleTypeFlagsKHR -> Int)
-> (VkExternalFenceHandleTypeFlagsKHR -> Bool)
-> (VkExternalFenceHandleTypeFlagsKHR
    -> Int -> VkExternalFenceHandleTypeFlagsKHR)
-> (VkExternalFenceHandleTypeFlagsKHR
    -> Int -> VkExternalFenceHandleTypeFlagsKHR)
-> (VkExternalFenceHandleTypeFlagsKHR
    -> Int -> VkExternalFenceHandleTypeFlagsKHR)
-> (VkExternalFenceHandleTypeFlagsKHR
    -> Int -> VkExternalFenceHandleTypeFlagsKHR)
-> (VkExternalFenceHandleTypeFlagsKHR
    -> Int -> VkExternalFenceHandleTypeFlagsKHR)
-> (VkExternalFenceHandleTypeFlagsKHR
    -> Int -> VkExternalFenceHandleTypeFlagsKHR)
-> (VkExternalFenceHandleTypeFlagsKHR -> Int)
-> Bits VkExternalFenceHandleTypeFlagsKHR
Int -> VkExternalFenceHandleTypeFlagsKHR
VkExternalFenceHandleTypeFlagsKHR -> Bool
VkExternalFenceHandleTypeFlagsKHR -> Int
VkExternalFenceHandleTypeFlagsKHR -> Maybe Int
VkExternalFenceHandleTypeFlagsKHR
-> VkExternalFenceHandleTypeFlagsKHR
VkExternalFenceHandleTypeFlagsKHR -> Int -> Bool
VkExternalFenceHandleTypeFlagsKHR
-> Int -> VkExternalFenceHandleTypeFlagsKHR
VkExternalFenceHandleTypeFlagsKHR
-> VkExternalFenceHandleTypeFlagsKHR
-> VkExternalFenceHandleTypeFlagsKHR
forall a.
Eq a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
popCount :: VkExternalFenceHandleTypeFlagsKHR -> Int
$cpopCount :: VkExternalFenceHandleTypeFlagsKHR -> Int
rotateR :: VkExternalFenceHandleTypeFlagsKHR
-> Int -> VkExternalFenceHandleTypeFlagsKHR
$crotateR :: VkExternalFenceHandleTypeFlagsKHR
-> Int -> VkExternalFenceHandleTypeFlagsKHR
rotateL :: VkExternalFenceHandleTypeFlagsKHR
-> Int -> VkExternalFenceHandleTypeFlagsKHR
$crotateL :: VkExternalFenceHandleTypeFlagsKHR
-> Int -> VkExternalFenceHandleTypeFlagsKHR
unsafeShiftR :: VkExternalFenceHandleTypeFlagsKHR
-> Int -> VkExternalFenceHandleTypeFlagsKHR
$cunsafeShiftR :: VkExternalFenceHandleTypeFlagsKHR
-> Int -> VkExternalFenceHandleTypeFlagsKHR
shiftR :: VkExternalFenceHandleTypeFlagsKHR
-> Int -> VkExternalFenceHandleTypeFlagsKHR
$cshiftR :: VkExternalFenceHandleTypeFlagsKHR
-> Int -> VkExternalFenceHandleTypeFlagsKHR
unsafeShiftL :: VkExternalFenceHandleTypeFlagsKHR
-> Int -> VkExternalFenceHandleTypeFlagsKHR
$cunsafeShiftL :: VkExternalFenceHandleTypeFlagsKHR
-> Int -> VkExternalFenceHandleTypeFlagsKHR
shiftL :: VkExternalFenceHandleTypeFlagsKHR
-> Int -> VkExternalFenceHandleTypeFlagsKHR
$cshiftL :: VkExternalFenceHandleTypeFlagsKHR
-> Int -> VkExternalFenceHandleTypeFlagsKHR
isSigned :: VkExternalFenceHandleTypeFlagsKHR -> Bool
$cisSigned :: VkExternalFenceHandleTypeFlagsKHR -> Bool
bitSize :: VkExternalFenceHandleTypeFlagsKHR -> Int
$cbitSize :: VkExternalFenceHandleTypeFlagsKHR -> Int
bitSizeMaybe :: VkExternalFenceHandleTypeFlagsKHR -> Maybe Int
$cbitSizeMaybe :: VkExternalFenceHandleTypeFlagsKHR -> Maybe Int
testBit :: VkExternalFenceHandleTypeFlagsKHR -> Int -> Bool
$ctestBit :: VkExternalFenceHandleTypeFlagsKHR -> Int -> Bool
complementBit :: VkExternalFenceHandleTypeFlagsKHR
-> Int -> VkExternalFenceHandleTypeFlagsKHR
$ccomplementBit :: VkExternalFenceHandleTypeFlagsKHR
-> Int -> VkExternalFenceHandleTypeFlagsKHR
clearBit :: VkExternalFenceHandleTypeFlagsKHR
-> Int -> VkExternalFenceHandleTypeFlagsKHR
$cclearBit :: VkExternalFenceHandleTypeFlagsKHR
-> Int -> VkExternalFenceHandleTypeFlagsKHR
setBit :: VkExternalFenceHandleTypeFlagsKHR
-> Int -> VkExternalFenceHandleTypeFlagsKHR
$csetBit :: VkExternalFenceHandleTypeFlagsKHR
-> Int -> VkExternalFenceHandleTypeFlagsKHR
bit :: Int -> VkExternalFenceHandleTypeFlagsKHR
$cbit :: Int -> VkExternalFenceHandleTypeFlagsKHR
zeroBits :: VkExternalFenceHandleTypeFlagsKHR
$czeroBits :: VkExternalFenceHandleTypeFlagsKHR
rotate :: VkExternalFenceHandleTypeFlagsKHR
-> Int -> VkExternalFenceHandleTypeFlagsKHR
$crotate :: VkExternalFenceHandleTypeFlagsKHR
-> Int -> VkExternalFenceHandleTypeFlagsKHR
shift :: VkExternalFenceHandleTypeFlagsKHR
-> Int -> VkExternalFenceHandleTypeFlagsKHR
$cshift :: VkExternalFenceHandleTypeFlagsKHR
-> Int -> VkExternalFenceHandleTypeFlagsKHR
complement :: VkExternalFenceHandleTypeFlagsKHR
-> VkExternalFenceHandleTypeFlagsKHR
$ccomplement :: VkExternalFenceHandleTypeFlagsKHR
-> VkExternalFenceHandleTypeFlagsKHR
xor :: VkExternalFenceHandleTypeFlagsKHR
-> VkExternalFenceHandleTypeFlagsKHR
-> VkExternalFenceHandleTypeFlagsKHR
$cxor :: VkExternalFenceHandleTypeFlagsKHR
-> VkExternalFenceHandleTypeFlagsKHR
-> VkExternalFenceHandleTypeFlagsKHR
.|. :: VkExternalFenceHandleTypeFlagsKHR
-> VkExternalFenceHandleTypeFlagsKHR
-> VkExternalFenceHandleTypeFlagsKHR
$c.|. :: VkExternalFenceHandleTypeFlagsKHR
-> VkExternalFenceHandleTypeFlagsKHR
-> VkExternalFenceHandleTypeFlagsKHR
.&. :: VkExternalFenceHandleTypeFlagsKHR
-> VkExternalFenceHandleTypeFlagsKHR
-> VkExternalFenceHandleTypeFlagsKHR
$c.&. :: VkExternalFenceHandleTypeFlagsKHR
-> VkExternalFenceHandleTypeFlagsKHR
-> VkExternalFenceHandleTypeFlagsKHR
Bits, Bits VkExternalFenceHandleTypeFlagsKHR
Bits VkExternalFenceHandleTypeFlagsKHR
-> (VkExternalFenceHandleTypeFlagsKHR -> Int)
-> (VkExternalFenceHandleTypeFlagsKHR -> Int)
-> (VkExternalFenceHandleTypeFlagsKHR -> Int)
-> FiniteBits VkExternalFenceHandleTypeFlagsKHR
VkExternalFenceHandleTypeFlagsKHR -> Int
forall b.
Bits b -> (b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
countTrailingZeros :: VkExternalFenceHandleTypeFlagsKHR -> Int
$ccountTrailingZeros :: VkExternalFenceHandleTypeFlagsKHR -> Int
countLeadingZeros :: VkExternalFenceHandleTypeFlagsKHR -> Int
$ccountLeadingZeros :: VkExternalFenceHandleTypeFlagsKHR -> Int
finiteBitSize :: VkExternalFenceHandleTypeFlagsKHR -> Int
$cfiniteBitSize :: VkExternalFenceHandleTypeFlagsKHR -> Int
FiniteBits, Ptr VkExternalFenceHandleTypeFlagsKHR
-> IO VkExternalFenceHandleTypeFlagsKHR
Ptr VkExternalFenceHandleTypeFlagsKHR
-> Int -> IO VkExternalFenceHandleTypeFlagsKHR
Ptr VkExternalFenceHandleTypeFlagsKHR
-> Int -> VkExternalFenceHandleTypeFlagsKHR -> IO ()
Ptr VkExternalFenceHandleTypeFlagsKHR
-> VkExternalFenceHandleTypeFlagsKHR -> IO ()
VkExternalFenceHandleTypeFlagsKHR -> Int
(VkExternalFenceHandleTypeFlagsKHR -> Int)
-> (VkExternalFenceHandleTypeFlagsKHR -> Int)
-> (Ptr VkExternalFenceHandleTypeFlagsKHR
    -> Int -> IO VkExternalFenceHandleTypeFlagsKHR)
-> (Ptr VkExternalFenceHandleTypeFlagsKHR
    -> Int -> VkExternalFenceHandleTypeFlagsKHR -> IO ())
-> (forall b. Ptr b -> Int -> IO VkExternalFenceHandleTypeFlagsKHR)
-> (forall b.
    Ptr b -> Int -> VkExternalFenceHandleTypeFlagsKHR -> IO ())
-> (Ptr VkExternalFenceHandleTypeFlagsKHR
    -> IO VkExternalFenceHandleTypeFlagsKHR)
-> (Ptr VkExternalFenceHandleTypeFlagsKHR
    -> VkExternalFenceHandleTypeFlagsKHR -> IO ())
-> Storable VkExternalFenceHandleTypeFlagsKHR
forall b. Ptr b -> Int -> IO VkExternalFenceHandleTypeFlagsKHR
forall b.
Ptr b -> Int -> VkExternalFenceHandleTypeFlagsKHR -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr VkExternalFenceHandleTypeFlagsKHR
-> VkExternalFenceHandleTypeFlagsKHR -> IO ()
$cpoke :: Ptr VkExternalFenceHandleTypeFlagsKHR
-> VkExternalFenceHandleTypeFlagsKHR -> IO ()
peek :: Ptr VkExternalFenceHandleTypeFlagsKHR
-> IO VkExternalFenceHandleTypeFlagsKHR
$cpeek :: Ptr VkExternalFenceHandleTypeFlagsKHR
-> IO VkExternalFenceHandleTypeFlagsKHR
pokeByteOff :: forall b.
Ptr b -> Int -> VkExternalFenceHandleTypeFlagsKHR -> IO ()
$cpokeByteOff :: forall b.
Ptr b -> Int -> VkExternalFenceHandleTypeFlagsKHR -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO VkExternalFenceHandleTypeFlagsKHR
$cpeekByteOff :: forall b. Ptr b -> Int -> IO VkExternalFenceHandleTypeFlagsKHR
pokeElemOff :: Ptr VkExternalFenceHandleTypeFlagsKHR
-> Int -> VkExternalFenceHandleTypeFlagsKHR -> IO ()
$cpokeElemOff :: Ptr VkExternalFenceHandleTypeFlagsKHR
-> Int -> VkExternalFenceHandleTypeFlagsKHR -> IO ()
peekElemOff :: Ptr VkExternalFenceHandleTypeFlagsKHR
-> Int -> IO VkExternalFenceHandleTypeFlagsKHR
$cpeekElemOff :: Ptr VkExternalFenceHandleTypeFlagsKHR
-> Int -> IO VkExternalFenceHandleTypeFlagsKHR
alignment :: VkExternalFenceHandleTypeFlagsKHR -> Int
$calignment :: VkExternalFenceHandleTypeFlagsKHR -> Int
sizeOf :: VkExternalFenceHandleTypeFlagsKHR -> Int
$csizeOf :: VkExternalFenceHandleTypeFlagsKHR -> Int
Storable)

instance Show VkExternalFenceHandleTypeFlagsKHR where
    {-# INLINE showsPrec #-}
    showsPrec :: Int -> VkExternalFenceHandleTypeFlagsKHR -> ShowS
showsPrec = (Int -> VkFlags -> ShowS)
-> Int -> VkExternalFenceHandleTypeFlagsKHR -> ShowS
coerce (Int -> VkFlags -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec :: Int -> VkFlags -> ShowS)

instance Read VkExternalFenceHandleTypeFlagsKHR where
    {-# INLINE readsPrec #-}
    readsPrec :: Int -> ReadS VkExternalFenceHandleTypeFlagsKHR
readsPrec = (Int -> ReadS VkFlags)
-> Int -> ReadS VkExternalFenceHandleTypeFlagsKHR
coerce (Int -> ReadS VkFlags
forall a. Read a => Int -> ReadS a
readsPrec :: Int -> ReadS VkFlags)

newtype VkExternalMemoryFeatureFlagsKHR = VkExternalMemoryFeatureFlagsKHR VkFlags
                                          deriving (VkExternalMemoryFeatureFlagsKHR
-> VkExternalMemoryFeatureFlagsKHR -> Bool
(VkExternalMemoryFeatureFlagsKHR
 -> VkExternalMemoryFeatureFlagsKHR -> Bool)
-> (VkExternalMemoryFeatureFlagsKHR
    -> VkExternalMemoryFeatureFlagsKHR -> Bool)
-> Eq VkExternalMemoryFeatureFlagsKHR
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VkExternalMemoryFeatureFlagsKHR
-> VkExternalMemoryFeatureFlagsKHR -> Bool
$c/= :: VkExternalMemoryFeatureFlagsKHR
-> VkExternalMemoryFeatureFlagsKHR -> Bool
== :: VkExternalMemoryFeatureFlagsKHR
-> VkExternalMemoryFeatureFlagsKHR -> Bool
$c== :: VkExternalMemoryFeatureFlagsKHR
-> VkExternalMemoryFeatureFlagsKHR -> Bool
Eq, Eq VkExternalMemoryFeatureFlagsKHR
Eq VkExternalMemoryFeatureFlagsKHR
-> (VkExternalMemoryFeatureFlagsKHR
    -> VkExternalMemoryFeatureFlagsKHR -> Ordering)
-> (VkExternalMemoryFeatureFlagsKHR
    -> VkExternalMemoryFeatureFlagsKHR -> Bool)
-> (VkExternalMemoryFeatureFlagsKHR
    -> VkExternalMemoryFeatureFlagsKHR -> Bool)
-> (VkExternalMemoryFeatureFlagsKHR
    -> VkExternalMemoryFeatureFlagsKHR -> Bool)
-> (VkExternalMemoryFeatureFlagsKHR
    -> VkExternalMemoryFeatureFlagsKHR -> Bool)
-> (VkExternalMemoryFeatureFlagsKHR
    -> VkExternalMemoryFeatureFlagsKHR
    -> VkExternalMemoryFeatureFlagsKHR)
-> (VkExternalMemoryFeatureFlagsKHR
    -> VkExternalMemoryFeatureFlagsKHR
    -> VkExternalMemoryFeatureFlagsKHR)
-> Ord VkExternalMemoryFeatureFlagsKHR
VkExternalMemoryFeatureFlagsKHR
-> VkExternalMemoryFeatureFlagsKHR -> Bool
VkExternalMemoryFeatureFlagsKHR
-> VkExternalMemoryFeatureFlagsKHR -> Ordering
VkExternalMemoryFeatureFlagsKHR
-> VkExternalMemoryFeatureFlagsKHR
-> VkExternalMemoryFeatureFlagsKHR
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: VkExternalMemoryFeatureFlagsKHR
-> VkExternalMemoryFeatureFlagsKHR
-> VkExternalMemoryFeatureFlagsKHR
$cmin :: VkExternalMemoryFeatureFlagsKHR
-> VkExternalMemoryFeatureFlagsKHR
-> VkExternalMemoryFeatureFlagsKHR
max :: VkExternalMemoryFeatureFlagsKHR
-> VkExternalMemoryFeatureFlagsKHR
-> VkExternalMemoryFeatureFlagsKHR
$cmax :: VkExternalMemoryFeatureFlagsKHR
-> VkExternalMemoryFeatureFlagsKHR
-> VkExternalMemoryFeatureFlagsKHR
>= :: VkExternalMemoryFeatureFlagsKHR
-> VkExternalMemoryFeatureFlagsKHR -> Bool
$c>= :: VkExternalMemoryFeatureFlagsKHR
-> VkExternalMemoryFeatureFlagsKHR -> Bool
> :: VkExternalMemoryFeatureFlagsKHR
-> VkExternalMemoryFeatureFlagsKHR -> Bool
$c> :: VkExternalMemoryFeatureFlagsKHR
-> VkExternalMemoryFeatureFlagsKHR -> Bool
<= :: VkExternalMemoryFeatureFlagsKHR
-> VkExternalMemoryFeatureFlagsKHR -> Bool
$c<= :: VkExternalMemoryFeatureFlagsKHR
-> VkExternalMemoryFeatureFlagsKHR -> Bool
< :: VkExternalMemoryFeatureFlagsKHR
-> VkExternalMemoryFeatureFlagsKHR -> Bool
$c< :: VkExternalMemoryFeatureFlagsKHR
-> VkExternalMemoryFeatureFlagsKHR -> Bool
compare :: VkExternalMemoryFeatureFlagsKHR
-> VkExternalMemoryFeatureFlagsKHR -> Ordering
$ccompare :: VkExternalMemoryFeatureFlagsKHR
-> VkExternalMemoryFeatureFlagsKHR -> Ordering
Ord, Int -> VkExternalMemoryFeatureFlagsKHR
VkExternalMemoryFeatureFlagsKHR -> Int
VkExternalMemoryFeatureFlagsKHR
-> [VkExternalMemoryFeatureFlagsKHR]
VkExternalMemoryFeatureFlagsKHR -> VkExternalMemoryFeatureFlagsKHR
VkExternalMemoryFeatureFlagsKHR
-> VkExternalMemoryFeatureFlagsKHR
-> [VkExternalMemoryFeatureFlagsKHR]
VkExternalMemoryFeatureFlagsKHR
-> VkExternalMemoryFeatureFlagsKHR
-> VkExternalMemoryFeatureFlagsKHR
-> [VkExternalMemoryFeatureFlagsKHR]
(VkExternalMemoryFeatureFlagsKHR
 -> VkExternalMemoryFeatureFlagsKHR)
-> (VkExternalMemoryFeatureFlagsKHR
    -> VkExternalMemoryFeatureFlagsKHR)
-> (Int -> VkExternalMemoryFeatureFlagsKHR)
-> (VkExternalMemoryFeatureFlagsKHR -> Int)
-> (VkExternalMemoryFeatureFlagsKHR
    -> [VkExternalMemoryFeatureFlagsKHR])
-> (VkExternalMemoryFeatureFlagsKHR
    -> VkExternalMemoryFeatureFlagsKHR
    -> [VkExternalMemoryFeatureFlagsKHR])
-> (VkExternalMemoryFeatureFlagsKHR
    -> VkExternalMemoryFeatureFlagsKHR
    -> [VkExternalMemoryFeatureFlagsKHR])
-> (VkExternalMemoryFeatureFlagsKHR
    -> VkExternalMemoryFeatureFlagsKHR
    -> VkExternalMemoryFeatureFlagsKHR
    -> [VkExternalMemoryFeatureFlagsKHR])
-> Enum VkExternalMemoryFeatureFlagsKHR
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: VkExternalMemoryFeatureFlagsKHR
-> VkExternalMemoryFeatureFlagsKHR
-> VkExternalMemoryFeatureFlagsKHR
-> [VkExternalMemoryFeatureFlagsKHR]
$cenumFromThenTo :: VkExternalMemoryFeatureFlagsKHR
-> VkExternalMemoryFeatureFlagsKHR
-> VkExternalMemoryFeatureFlagsKHR
-> [VkExternalMemoryFeatureFlagsKHR]
enumFromTo :: VkExternalMemoryFeatureFlagsKHR
-> VkExternalMemoryFeatureFlagsKHR
-> [VkExternalMemoryFeatureFlagsKHR]
$cenumFromTo :: VkExternalMemoryFeatureFlagsKHR
-> VkExternalMemoryFeatureFlagsKHR
-> [VkExternalMemoryFeatureFlagsKHR]
enumFromThen :: VkExternalMemoryFeatureFlagsKHR
-> VkExternalMemoryFeatureFlagsKHR
-> [VkExternalMemoryFeatureFlagsKHR]
$cenumFromThen :: VkExternalMemoryFeatureFlagsKHR
-> VkExternalMemoryFeatureFlagsKHR
-> [VkExternalMemoryFeatureFlagsKHR]
enumFrom :: VkExternalMemoryFeatureFlagsKHR
-> [VkExternalMemoryFeatureFlagsKHR]
$cenumFrom :: VkExternalMemoryFeatureFlagsKHR
-> [VkExternalMemoryFeatureFlagsKHR]
fromEnum :: VkExternalMemoryFeatureFlagsKHR -> Int
$cfromEnum :: VkExternalMemoryFeatureFlagsKHR -> Int
toEnum :: Int -> VkExternalMemoryFeatureFlagsKHR
$ctoEnum :: Int -> VkExternalMemoryFeatureFlagsKHR
pred :: VkExternalMemoryFeatureFlagsKHR -> VkExternalMemoryFeatureFlagsKHR
$cpred :: VkExternalMemoryFeatureFlagsKHR -> VkExternalMemoryFeatureFlagsKHR
succ :: VkExternalMemoryFeatureFlagsKHR -> VkExternalMemoryFeatureFlagsKHR
$csucc :: VkExternalMemoryFeatureFlagsKHR -> VkExternalMemoryFeatureFlagsKHR
Enum, Eq VkExternalMemoryFeatureFlagsKHR
VkExternalMemoryFeatureFlagsKHR
Eq VkExternalMemoryFeatureFlagsKHR
-> (VkExternalMemoryFeatureFlagsKHR
    -> VkExternalMemoryFeatureFlagsKHR
    -> VkExternalMemoryFeatureFlagsKHR)
-> (VkExternalMemoryFeatureFlagsKHR
    -> VkExternalMemoryFeatureFlagsKHR
    -> VkExternalMemoryFeatureFlagsKHR)
-> (VkExternalMemoryFeatureFlagsKHR
    -> VkExternalMemoryFeatureFlagsKHR
    -> VkExternalMemoryFeatureFlagsKHR)
-> (VkExternalMemoryFeatureFlagsKHR
    -> VkExternalMemoryFeatureFlagsKHR)
-> (VkExternalMemoryFeatureFlagsKHR
    -> Int -> VkExternalMemoryFeatureFlagsKHR)
-> (VkExternalMemoryFeatureFlagsKHR
    -> Int -> VkExternalMemoryFeatureFlagsKHR)
-> VkExternalMemoryFeatureFlagsKHR
-> (Int -> VkExternalMemoryFeatureFlagsKHR)
-> (VkExternalMemoryFeatureFlagsKHR
    -> Int -> VkExternalMemoryFeatureFlagsKHR)
-> (VkExternalMemoryFeatureFlagsKHR
    -> Int -> VkExternalMemoryFeatureFlagsKHR)
-> (VkExternalMemoryFeatureFlagsKHR
    -> Int -> VkExternalMemoryFeatureFlagsKHR)
-> (VkExternalMemoryFeatureFlagsKHR -> Int -> Bool)
-> (VkExternalMemoryFeatureFlagsKHR -> Maybe Int)
-> (VkExternalMemoryFeatureFlagsKHR -> Int)
-> (VkExternalMemoryFeatureFlagsKHR -> Bool)
-> (VkExternalMemoryFeatureFlagsKHR
    -> Int -> VkExternalMemoryFeatureFlagsKHR)
-> (VkExternalMemoryFeatureFlagsKHR
    -> Int -> VkExternalMemoryFeatureFlagsKHR)
-> (VkExternalMemoryFeatureFlagsKHR
    -> Int -> VkExternalMemoryFeatureFlagsKHR)
-> (VkExternalMemoryFeatureFlagsKHR
    -> Int -> VkExternalMemoryFeatureFlagsKHR)
-> (VkExternalMemoryFeatureFlagsKHR
    -> Int -> VkExternalMemoryFeatureFlagsKHR)
-> (VkExternalMemoryFeatureFlagsKHR
    -> Int -> VkExternalMemoryFeatureFlagsKHR)
-> (VkExternalMemoryFeatureFlagsKHR -> Int)
-> Bits VkExternalMemoryFeatureFlagsKHR
Int -> VkExternalMemoryFeatureFlagsKHR
VkExternalMemoryFeatureFlagsKHR -> Bool
VkExternalMemoryFeatureFlagsKHR -> Int
VkExternalMemoryFeatureFlagsKHR -> Maybe Int
VkExternalMemoryFeatureFlagsKHR -> VkExternalMemoryFeatureFlagsKHR
VkExternalMemoryFeatureFlagsKHR -> Int -> Bool
VkExternalMemoryFeatureFlagsKHR
-> Int -> VkExternalMemoryFeatureFlagsKHR
VkExternalMemoryFeatureFlagsKHR
-> VkExternalMemoryFeatureFlagsKHR
-> VkExternalMemoryFeatureFlagsKHR
forall a.
Eq a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
popCount :: VkExternalMemoryFeatureFlagsKHR -> Int
$cpopCount :: VkExternalMemoryFeatureFlagsKHR -> Int
rotateR :: VkExternalMemoryFeatureFlagsKHR
-> Int -> VkExternalMemoryFeatureFlagsKHR
$crotateR :: VkExternalMemoryFeatureFlagsKHR
-> Int -> VkExternalMemoryFeatureFlagsKHR
rotateL :: VkExternalMemoryFeatureFlagsKHR
-> Int -> VkExternalMemoryFeatureFlagsKHR
$crotateL :: VkExternalMemoryFeatureFlagsKHR
-> Int -> VkExternalMemoryFeatureFlagsKHR
unsafeShiftR :: VkExternalMemoryFeatureFlagsKHR
-> Int -> VkExternalMemoryFeatureFlagsKHR
$cunsafeShiftR :: VkExternalMemoryFeatureFlagsKHR
-> Int -> VkExternalMemoryFeatureFlagsKHR
shiftR :: VkExternalMemoryFeatureFlagsKHR
-> Int -> VkExternalMemoryFeatureFlagsKHR
$cshiftR :: VkExternalMemoryFeatureFlagsKHR
-> Int -> VkExternalMemoryFeatureFlagsKHR
unsafeShiftL :: VkExternalMemoryFeatureFlagsKHR
-> Int -> VkExternalMemoryFeatureFlagsKHR
$cunsafeShiftL :: VkExternalMemoryFeatureFlagsKHR
-> Int -> VkExternalMemoryFeatureFlagsKHR
shiftL :: VkExternalMemoryFeatureFlagsKHR
-> Int -> VkExternalMemoryFeatureFlagsKHR
$cshiftL :: VkExternalMemoryFeatureFlagsKHR
-> Int -> VkExternalMemoryFeatureFlagsKHR
isSigned :: VkExternalMemoryFeatureFlagsKHR -> Bool
$cisSigned :: VkExternalMemoryFeatureFlagsKHR -> Bool
bitSize :: VkExternalMemoryFeatureFlagsKHR -> Int
$cbitSize :: VkExternalMemoryFeatureFlagsKHR -> Int
bitSizeMaybe :: VkExternalMemoryFeatureFlagsKHR -> Maybe Int
$cbitSizeMaybe :: VkExternalMemoryFeatureFlagsKHR -> Maybe Int
testBit :: VkExternalMemoryFeatureFlagsKHR -> Int -> Bool
$ctestBit :: VkExternalMemoryFeatureFlagsKHR -> Int -> Bool
complementBit :: VkExternalMemoryFeatureFlagsKHR
-> Int -> VkExternalMemoryFeatureFlagsKHR
$ccomplementBit :: VkExternalMemoryFeatureFlagsKHR
-> Int -> VkExternalMemoryFeatureFlagsKHR
clearBit :: VkExternalMemoryFeatureFlagsKHR
-> Int -> VkExternalMemoryFeatureFlagsKHR
$cclearBit :: VkExternalMemoryFeatureFlagsKHR
-> Int -> VkExternalMemoryFeatureFlagsKHR
setBit :: VkExternalMemoryFeatureFlagsKHR
-> Int -> VkExternalMemoryFeatureFlagsKHR
$csetBit :: VkExternalMemoryFeatureFlagsKHR
-> Int -> VkExternalMemoryFeatureFlagsKHR
bit :: Int -> VkExternalMemoryFeatureFlagsKHR
$cbit :: Int -> VkExternalMemoryFeatureFlagsKHR
zeroBits :: VkExternalMemoryFeatureFlagsKHR
$czeroBits :: VkExternalMemoryFeatureFlagsKHR
rotate :: VkExternalMemoryFeatureFlagsKHR
-> Int -> VkExternalMemoryFeatureFlagsKHR
$crotate :: VkExternalMemoryFeatureFlagsKHR
-> Int -> VkExternalMemoryFeatureFlagsKHR
shift :: VkExternalMemoryFeatureFlagsKHR
-> Int -> VkExternalMemoryFeatureFlagsKHR
$cshift :: VkExternalMemoryFeatureFlagsKHR
-> Int -> VkExternalMemoryFeatureFlagsKHR
complement :: VkExternalMemoryFeatureFlagsKHR -> VkExternalMemoryFeatureFlagsKHR
$ccomplement :: VkExternalMemoryFeatureFlagsKHR -> VkExternalMemoryFeatureFlagsKHR
xor :: VkExternalMemoryFeatureFlagsKHR
-> VkExternalMemoryFeatureFlagsKHR
-> VkExternalMemoryFeatureFlagsKHR
$cxor :: VkExternalMemoryFeatureFlagsKHR
-> VkExternalMemoryFeatureFlagsKHR
-> VkExternalMemoryFeatureFlagsKHR
.|. :: VkExternalMemoryFeatureFlagsKHR
-> VkExternalMemoryFeatureFlagsKHR
-> VkExternalMemoryFeatureFlagsKHR
$c.|. :: VkExternalMemoryFeatureFlagsKHR
-> VkExternalMemoryFeatureFlagsKHR
-> VkExternalMemoryFeatureFlagsKHR
.&. :: VkExternalMemoryFeatureFlagsKHR
-> VkExternalMemoryFeatureFlagsKHR
-> VkExternalMemoryFeatureFlagsKHR
$c.&. :: VkExternalMemoryFeatureFlagsKHR
-> VkExternalMemoryFeatureFlagsKHR
-> VkExternalMemoryFeatureFlagsKHR
Bits, Bits VkExternalMemoryFeatureFlagsKHR
Bits VkExternalMemoryFeatureFlagsKHR
-> (VkExternalMemoryFeatureFlagsKHR -> Int)
-> (VkExternalMemoryFeatureFlagsKHR -> Int)
-> (VkExternalMemoryFeatureFlagsKHR -> Int)
-> FiniteBits VkExternalMemoryFeatureFlagsKHR
VkExternalMemoryFeatureFlagsKHR -> Int
forall b.
Bits b -> (b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
countTrailingZeros :: VkExternalMemoryFeatureFlagsKHR -> Int
$ccountTrailingZeros :: VkExternalMemoryFeatureFlagsKHR -> Int
countLeadingZeros :: VkExternalMemoryFeatureFlagsKHR -> Int
$ccountLeadingZeros :: VkExternalMemoryFeatureFlagsKHR -> Int
finiteBitSize :: VkExternalMemoryFeatureFlagsKHR -> Int
$cfiniteBitSize :: VkExternalMemoryFeatureFlagsKHR -> Int
FiniteBits, Ptr VkExternalMemoryFeatureFlagsKHR
-> IO VkExternalMemoryFeatureFlagsKHR
Ptr VkExternalMemoryFeatureFlagsKHR
-> Int -> IO VkExternalMemoryFeatureFlagsKHR
Ptr VkExternalMemoryFeatureFlagsKHR
-> Int -> VkExternalMemoryFeatureFlagsKHR -> IO ()
Ptr VkExternalMemoryFeatureFlagsKHR
-> VkExternalMemoryFeatureFlagsKHR -> IO ()
VkExternalMemoryFeatureFlagsKHR -> Int
(VkExternalMemoryFeatureFlagsKHR -> Int)
-> (VkExternalMemoryFeatureFlagsKHR -> Int)
-> (Ptr VkExternalMemoryFeatureFlagsKHR
    -> Int -> IO VkExternalMemoryFeatureFlagsKHR)
-> (Ptr VkExternalMemoryFeatureFlagsKHR
    -> Int -> VkExternalMemoryFeatureFlagsKHR -> IO ())
-> (forall b. Ptr b -> Int -> IO VkExternalMemoryFeatureFlagsKHR)
-> (forall b.
    Ptr b -> Int -> VkExternalMemoryFeatureFlagsKHR -> IO ())
-> (Ptr VkExternalMemoryFeatureFlagsKHR
    -> IO VkExternalMemoryFeatureFlagsKHR)
-> (Ptr VkExternalMemoryFeatureFlagsKHR
    -> VkExternalMemoryFeatureFlagsKHR -> IO ())
-> Storable VkExternalMemoryFeatureFlagsKHR
forall b. Ptr b -> Int -> IO VkExternalMemoryFeatureFlagsKHR
forall b. Ptr b -> Int -> VkExternalMemoryFeatureFlagsKHR -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr VkExternalMemoryFeatureFlagsKHR
-> VkExternalMemoryFeatureFlagsKHR -> IO ()
$cpoke :: Ptr VkExternalMemoryFeatureFlagsKHR
-> VkExternalMemoryFeatureFlagsKHR -> IO ()
peek :: Ptr VkExternalMemoryFeatureFlagsKHR
-> IO VkExternalMemoryFeatureFlagsKHR
$cpeek :: Ptr VkExternalMemoryFeatureFlagsKHR
-> IO VkExternalMemoryFeatureFlagsKHR
pokeByteOff :: forall b. Ptr b -> Int -> VkExternalMemoryFeatureFlagsKHR -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> VkExternalMemoryFeatureFlagsKHR -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO VkExternalMemoryFeatureFlagsKHR
$cpeekByteOff :: forall b. Ptr b -> Int -> IO VkExternalMemoryFeatureFlagsKHR
pokeElemOff :: Ptr VkExternalMemoryFeatureFlagsKHR
-> Int -> VkExternalMemoryFeatureFlagsKHR -> IO ()
$cpokeElemOff :: Ptr VkExternalMemoryFeatureFlagsKHR
-> Int -> VkExternalMemoryFeatureFlagsKHR -> IO ()
peekElemOff :: Ptr VkExternalMemoryFeatureFlagsKHR
-> Int -> IO VkExternalMemoryFeatureFlagsKHR
$cpeekElemOff :: Ptr VkExternalMemoryFeatureFlagsKHR
-> Int -> IO VkExternalMemoryFeatureFlagsKHR
alignment :: VkExternalMemoryFeatureFlagsKHR -> Int
$calignment :: VkExternalMemoryFeatureFlagsKHR -> Int
sizeOf :: VkExternalMemoryFeatureFlagsKHR -> Int
$csizeOf :: VkExternalMemoryFeatureFlagsKHR -> Int
Storable)

instance Show VkExternalMemoryFeatureFlagsKHR where
    {-# INLINE showsPrec #-}
    showsPrec :: Int -> VkExternalMemoryFeatureFlagsKHR -> ShowS
showsPrec = (Int -> VkFlags -> ShowS)
-> Int -> VkExternalMemoryFeatureFlagsKHR -> ShowS
coerce (Int -> VkFlags -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec :: Int -> VkFlags -> ShowS)

instance Read VkExternalMemoryFeatureFlagsKHR where
    {-# INLINE readsPrec #-}
    readsPrec :: Int -> ReadS VkExternalMemoryFeatureFlagsKHR
readsPrec = (Int -> ReadS VkFlags)
-> Int -> ReadS VkExternalMemoryFeatureFlagsKHR
coerce (Int -> ReadS VkFlags
forall a. Read a => Int -> ReadS a
readsPrec :: Int -> ReadS VkFlags)

newtype VkExternalMemoryHandleTypeFlagsKHR = VkExternalMemoryHandleTypeFlagsKHR VkFlags
                                             deriving (VkExternalMemoryHandleTypeFlagsKHR
-> VkExternalMemoryHandleTypeFlagsKHR -> Bool
(VkExternalMemoryHandleTypeFlagsKHR
 -> VkExternalMemoryHandleTypeFlagsKHR -> Bool)
-> (VkExternalMemoryHandleTypeFlagsKHR
    -> VkExternalMemoryHandleTypeFlagsKHR -> Bool)
-> Eq VkExternalMemoryHandleTypeFlagsKHR
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VkExternalMemoryHandleTypeFlagsKHR
-> VkExternalMemoryHandleTypeFlagsKHR -> Bool
$c/= :: VkExternalMemoryHandleTypeFlagsKHR
-> VkExternalMemoryHandleTypeFlagsKHR -> Bool
== :: VkExternalMemoryHandleTypeFlagsKHR
-> VkExternalMemoryHandleTypeFlagsKHR -> Bool
$c== :: VkExternalMemoryHandleTypeFlagsKHR
-> VkExternalMemoryHandleTypeFlagsKHR -> Bool
Eq, Eq VkExternalMemoryHandleTypeFlagsKHR
Eq VkExternalMemoryHandleTypeFlagsKHR
-> (VkExternalMemoryHandleTypeFlagsKHR
    -> VkExternalMemoryHandleTypeFlagsKHR -> Ordering)
-> (VkExternalMemoryHandleTypeFlagsKHR
    -> VkExternalMemoryHandleTypeFlagsKHR -> Bool)
-> (VkExternalMemoryHandleTypeFlagsKHR
    -> VkExternalMemoryHandleTypeFlagsKHR -> Bool)
-> (VkExternalMemoryHandleTypeFlagsKHR
    -> VkExternalMemoryHandleTypeFlagsKHR -> Bool)
-> (VkExternalMemoryHandleTypeFlagsKHR
    -> VkExternalMemoryHandleTypeFlagsKHR -> Bool)
-> (VkExternalMemoryHandleTypeFlagsKHR
    -> VkExternalMemoryHandleTypeFlagsKHR
    -> VkExternalMemoryHandleTypeFlagsKHR)
-> (VkExternalMemoryHandleTypeFlagsKHR
    -> VkExternalMemoryHandleTypeFlagsKHR
    -> VkExternalMemoryHandleTypeFlagsKHR)
-> Ord VkExternalMemoryHandleTypeFlagsKHR
VkExternalMemoryHandleTypeFlagsKHR
-> VkExternalMemoryHandleTypeFlagsKHR -> Bool
VkExternalMemoryHandleTypeFlagsKHR
-> VkExternalMemoryHandleTypeFlagsKHR -> Ordering
VkExternalMemoryHandleTypeFlagsKHR
-> VkExternalMemoryHandleTypeFlagsKHR
-> VkExternalMemoryHandleTypeFlagsKHR
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: VkExternalMemoryHandleTypeFlagsKHR
-> VkExternalMemoryHandleTypeFlagsKHR
-> VkExternalMemoryHandleTypeFlagsKHR
$cmin :: VkExternalMemoryHandleTypeFlagsKHR
-> VkExternalMemoryHandleTypeFlagsKHR
-> VkExternalMemoryHandleTypeFlagsKHR
max :: VkExternalMemoryHandleTypeFlagsKHR
-> VkExternalMemoryHandleTypeFlagsKHR
-> VkExternalMemoryHandleTypeFlagsKHR
$cmax :: VkExternalMemoryHandleTypeFlagsKHR
-> VkExternalMemoryHandleTypeFlagsKHR
-> VkExternalMemoryHandleTypeFlagsKHR
>= :: VkExternalMemoryHandleTypeFlagsKHR
-> VkExternalMemoryHandleTypeFlagsKHR -> Bool
$c>= :: VkExternalMemoryHandleTypeFlagsKHR
-> VkExternalMemoryHandleTypeFlagsKHR -> Bool
> :: VkExternalMemoryHandleTypeFlagsKHR
-> VkExternalMemoryHandleTypeFlagsKHR -> Bool
$c> :: VkExternalMemoryHandleTypeFlagsKHR
-> VkExternalMemoryHandleTypeFlagsKHR -> Bool
<= :: VkExternalMemoryHandleTypeFlagsKHR
-> VkExternalMemoryHandleTypeFlagsKHR -> Bool
$c<= :: VkExternalMemoryHandleTypeFlagsKHR
-> VkExternalMemoryHandleTypeFlagsKHR -> Bool
< :: VkExternalMemoryHandleTypeFlagsKHR
-> VkExternalMemoryHandleTypeFlagsKHR -> Bool
$c< :: VkExternalMemoryHandleTypeFlagsKHR
-> VkExternalMemoryHandleTypeFlagsKHR -> Bool
compare :: VkExternalMemoryHandleTypeFlagsKHR
-> VkExternalMemoryHandleTypeFlagsKHR -> Ordering
$ccompare :: VkExternalMemoryHandleTypeFlagsKHR
-> VkExternalMemoryHandleTypeFlagsKHR -> Ordering
Ord, Int -> VkExternalMemoryHandleTypeFlagsKHR
VkExternalMemoryHandleTypeFlagsKHR -> Int
VkExternalMemoryHandleTypeFlagsKHR
-> [VkExternalMemoryHandleTypeFlagsKHR]
VkExternalMemoryHandleTypeFlagsKHR
-> VkExternalMemoryHandleTypeFlagsKHR
VkExternalMemoryHandleTypeFlagsKHR
-> VkExternalMemoryHandleTypeFlagsKHR
-> [VkExternalMemoryHandleTypeFlagsKHR]
VkExternalMemoryHandleTypeFlagsKHR
-> VkExternalMemoryHandleTypeFlagsKHR
-> VkExternalMemoryHandleTypeFlagsKHR
-> [VkExternalMemoryHandleTypeFlagsKHR]
(VkExternalMemoryHandleTypeFlagsKHR
 -> VkExternalMemoryHandleTypeFlagsKHR)
-> (VkExternalMemoryHandleTypeFlagsKHR
    -> VkExternalMemoryHandleTypeFlagsKHR)
-> (Int -> VkExternalMemoryHandleTypeFlagsKHR)
-> (VkExternalMemoryHandleTypeFlagsKHR -> Int)
-> (VkExternalMemoryHandleTypeFlagsKHR
    -> [VkExternalMemoryHandleTypeFlagsKHR])
-> (VkExternalMemoryHandleTypeFlagsKHR
    -> VkExternalMemoryHandleTypeFlagsKHR
    -> [VkExternalMemoryHandleTypeFlagsKHR])
-> (VkExternalMemoryHandleTypeFlagsKHR
    -> VkExternalMemoryHandleTypeFlagsKHR
    -> [VkExternalMemoryHandleTypeFlagsKHR])
-> (VkExternalMemoryHandleTypeFlagsKHR
    -> VkExternalMemoryHandleTypeFlagsKHR
    -> VkExternalMemoryHandleTypeFlagsKHR
    -> [VkExternalMemoryHandleTypeFlagsKHR])
-> Enum VkExternalMemoryHandleTypeFlagsKHR
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: VkExternalMemoryHandleTypeFlagsKHR
-> VkExternalMemoryHandleTypeFlagsKHR
-> VkExternalMemoryHandleTypeFlagsKHR
-> [VkExternalMemoryHandleTypeFlagsKHR]
$cenumFromThenTo :: VkExternalMemoryHandleTypeFlagsKHR
-> VkExternalMemoryHandleTypeFlagsKHR
-> VkExternalMemoryHandleTypeFlagsKHR
-> [VkExternalMemoryHandleTypeFlagsKHR]
enumFromTo :: VkExternalMemoryHandleTypeFlagsKHR
-> VkExternalMemoryHandleTypeFlagsKHR
-> [VkExternalMemoryHandleTypeFlagsKHR]
$cenumFromTo :: VkExternalMemoryHandleTypeFlagsKHR
-> VkExternalMemoryHandleTypeFlagsKHR
-> [VkExternalMemoryHandleTypeFlagsKHR]
enumFromThen :: VkExternalMemoryHandleTypeFlagsKHR
-> VkExternalMemoryHandleTypeFlagsKHR
-> [VkExternalMemoryHandleTypeFlagsKHR]
$cenumFromThen :: VkExternalMemoryHandleTypeFlagsKHR
-> VkExternalMemoryHandleTypeFlagsKHR
-> [VkExternalMemoryHandleTypeFlagsKHR]
enumFrom :: VkExternalMemoryHandleTypeFlagsKHR
-> [VkExternalMemoryHandleTypeFlagsKHR]
$cenumFrom :: VkExternalMemoryHandleTypeFlagsKHR
-> [VkExternalMemoryHandleTypeFlagsKHR]
fromEnum :: VkExternalMemoryHandleTypeFlagsKHR -> Int
$cfromEnum :: VkExternalMemoryHandleTypeFlagsKHR -> Int
toEnum :: Int -> VkExternalMemoryHandleTypeFlagsKHR
$ctoEnum :: Int -> VkExternalMemoryHandleTypeFlagsKHR
pred :: VkExternalMemoryHandleTypeFlagsKHR
-> VkExternalMemoryHandleTypeFlagsKHR
$cpred :: VkExternalMemoryHandleTypeFlagsKHR
-> VkExternalMemoryHandleTypeFlagsKHR
succ :: VkExternalMemoryHandleTypeFlagsKHR
-> VkExternalMemoryHandleTypeFlagsKHR
$csucc :: VkExternalMemoryHandleTypeFlagsKHR
-> VkExternalMemoryHandleTypeFlagsKHR
Enum, Eq VkExternalMemoryHandleTypeFlagsKHR
VkExternalMemoryHandleTypeFlagsKHR
Eq VkExternalMemoryHandleTypeFlagsKHR
-> (VkExternalMemoryHandleTypeFlagsKHR
    -> VkExternalMemoryHandleTypeFlagsKHR
    -> VkExternalMemoryHandleTypeFlagsKHR)
-> (VkExternalMemoryHandleTypeFlagsKHR
    -> VkExternalMemoryHandleTypeFlagsKHR
    -> VkExternalMemoryHandleTypeFlagsKHR)
-> (VkExternalMemoryHandleTypeFlagsKHR
    -> VkExternalMemoryHandleTypeFlagsKHR
    -> VkExternalMemoryHandleTypeFlagsKHR)
-> (VkExternalMemoryHandleTypeFlagsKHR
    -> VkExternalMemoryHandleTypeFlagsKHR)
-> (VkExternalMemoryHandleTypeFlagsKHR
    -> Int -> VkExternalMemoryHandleTypeFlagsKHR)
-> (VkExternalMemoryHandleTypeFlagsKHR
    -> Int -> VkExternalMemoryHandleTypeFlagsKHR)
-> VkExternalMemoryHandleTypeFlagsKHR
-> (Int -> VkExternalMemoryHandleTypeFlagsKHR)
-> (VkExternalMemoryHandleTypeFlagsKHR
    -> Int -> VkExternalMemoryHandleTypeFlagsKHR)
-> (VkExternalMemoryHandleTypeFlagsKHR
    -> Int -> VkExternalMemoryHandleTypeFlagsKHR)
-> (VkExternalMemoryHandleTypeFlagsKHR
    -> Int -> VkExternalMemoryHandleTypeFlagsKHR)
-> (VkExternalMemoryHandleTypeFlagsKHR -> Int -> Bool)
-> (VkExternalMemoryHandleTypeFlagsKHR -> Maybe Int)
-> (VkExternalMemoryHandleTypeFlagsKHR -> Int)
-> (VkExternalMemoryHandleTypeFlagsKHR -> Bool)
-> (VkExternalMemoryHandleTypeFlagsKHR
    -> Int -> VkExternalMemoryHandleTypeFlagsKHR)
-> (VkExternalMemoryHandleTypeFlagsKHR
    -> Int -> VkExternalMemoryHandleTypeFlagsKHR)
-> (VkExternalMemoryHandleTypeFlagsKHR
    -> Int -> VkExternalMemoryHandleTypeFlagsKHR)
-> (VkExternalMemoryHandleTypeFlagsKHR
    -> Int -> VkExternalMemoryHandleTypeFlagsKHR)
-> (VkExternalMemoryHandleTypeFlagsKHR
    -> Int -> VkExternalMemoryHandleTypeFlagsKHR)
-> (VkExternalMemoryHandleTypeFlagsKHR
    -> Int -> VkExternalMemoryHandleTypeFlagsKHR)
-> (VkExternalMemoryHandleTypeFlagsKHR -> Int)
-> Bits VkExternalMemoryHandleTypeFlagsKHR
Int -> VkExternalMemoryHandleTypeFlagsKHR
VkExternalMemoryHandleTypeFlagsKHR -> Bool
VkExternalMemoryHandleTypeFlagsKHR -> Int
VkExternalMemoryHandleTypeFlagsKHR -> Maybe Int
VkExternalMemoryHandleTypeFlagsKHR
-> VkExternalMemoryHandleTypeFlagsKHR
VkExternalMemoryHandleTypeFlagsKHR -> Int -> Bool
VkExternalMemoryHandleTypeFlagsKHR
-> Int -> VkExternalMemoryHandleTypeFlagsKHR
VkExternalMemoryHandleTypeFlagsKHR
-> VkExternalMemoryHandleTypeFlagsKHR
-> VkExternalMemoryHandleTypeFlagsKHR
forall a.
Eq a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
popCount :: VkExternalMemoryHandleTypeFlagsKHR -> Int
$cpopCount :: VkExternalMemoryHandleTypeFlagsKHR -> Int
rotateR :: VkExternalMemoryHandleTypeFlagsKHR
-> Int -> VkExternalMemoryHandleTypeFlagsKHR
$crotateR :: VkExternalMemoryHandleTypeFlagsKHR
-> Int -> VkExternalMemoryHandleTypeFlagsKHR
rotateL :: VkExternalMemoryHandleTypeFlagsKHR
-> Int -> VkExternalMemoryHandleTypeFlagsKHR
$crotateL :: VkExternalMemoryHandleTypeFlagsKHR
-> Int -> VkExternalMemoryHandleTypeFlagsKHR
unsafeShiftR :: VkExternalMemoryHandleTypeFlagsKHR
-> Int -> VkExternalMemoryHandleTypeFlagsKHR
$cunsafeShiftR :: VkExternalMemoryHandleTypeFlagsKHR
-> Int -> VkExternalMemoryHandleTypeFlagsKHR
shiftR :: VkExternalMemoryHandleTypeFlagsKHR
-> Int -> VkExternalMemoryHandleTypeFlagsKHR
$cshiftR :: VkExternalMemoryHandleTypeFlagsKHR
-> Int -> VkExternalMemoryHandleTypeFlagsKHR
unsafeShiftL :: VkExternalMemoryHandleTypeFlagsKHR
-> Int -> VkExternalMemoryHandleTypeFlagsKHR
$cunsafeShiftL :: VkExternalMemoryHandleTypeFlagsKHR
-> Int -> VkExternalMemoryHandleTypeFlagsKHR
shiftL :: VkExternalMemoryHandleTypeFlagsKHR
-> Int -> VkExternalMemoryHandleTypeFlagsKHR
$cshiftL :: VkExternalMemoryHandleTypeFlagsKHR
-> Int -> VkExternalMemoryHandleTypeFlagsKHR
isSigned :: VkExternalMemoryHandleTypeFlagsKHR -> Bool
$cisSigned :: VkExternalMemoryHandleTypeFlagsKHR -> Bool
bitSize :: VkExternalMemoryHandleTypeFlagsKHR -> Int
$cbitSize :: VkExternalMemoryHandleTypeFlagsKHR -> Int
bitSizeMaybe :: VkExternalMemoryHandleTypeFlagsKHR -> Maybe Int
$cbitSizeMaybe :: VkExternalMemoryHandleTypeFlagsKHR -> Maybe Int
testBit :: VkExternalMemoryHandleTypeFlagsKHR -> Int -> Bool
$ctestBit :: VkExternalMemoryHandleTypeFlagsKHR -> Int -> Bool
complementBit :: VkExternalMemoryHandleTypeFlagsKHR
-> Int -> VkExternalMemoryHandleTypeFlagsKHR
$ccomplementBit :: VkExternalMemoryHandleTypeFlagsKHR
-> Int -> VkExternalMemoryHandleTypeFlagsKHR
clearBit :: VkExternalMemoryHandleTypeFlagsKHR
-> Int -> VkExternalMemoryHandleTypeFlagsKHR
$cclearBit :: VkExternalMemoryHandleTypeFlagsKHR
-> Int -> VkExternalMemoryHandleTypeFlagsKHR
setBit :: VkExternalMemoryHandleTypeFlagsKHR
-> Int -> VkExternalMemoryHandleTypeFlagsKHR
$csetBit :: VkExternalMemoryHandleTypeFlagsKHR
-> Int -> VkExternalMemoryHandleTypeFlagsKHR
bit :: Int -> VkExternalMemoryHandleTypeFlagsKHR
$cbit :: Int -> VkExternalMemoryHandleTypeFlagsKHR
zeroBits :: VkExternalMemoryHandleTypeFlagsKHR
$czeroBits :: VkExternalMemoryHandleTypeFlagsKHR
rotate :: VkExternalMemoryHandleTypeFlagsKHR
-> Int -> VkExternalMemoryHandleTypeFlagsKHR
$crotate :: VkExternalMemoryHandleTypeFlagsKHR
-> Int -> VkExternalMemoryHandleTypeFlagsKHR
shift :: VkExternalMemoryHandleTypeFlagsKHR
-> Int -> VkExternalMemoryHandleTypeFlagsKHR
$cshift :: VkExternalMemoryHandleTypeFlagsKHR
-> Int -> VkExternalMemoryHandleTypeFlagsKHR
complement :: VkExternalMemoryHandleTypeFlagsKHR
-> VkExternalMemoryHandleTypeFlagsKHR
$ccomplement :: VkExternalMemoryHandleTypeFlagsKHR
-> VkExternalMemoryHandleTypeFlagsKHR
xor :: VkExternalMemoryHandleTypeFlagsKHR
-> VkExternalMemoryHandleTypeFlagsKHR
-> VkExternalMemoryHandleTypeFlagsKHR
$cxor :: VkExternalMemoryHandleTypeFlagsKHR
-> VkExternalMemoryHandleTypeFlagsKHR
-> VkExternalMemoryHandleTypeFlagsKHR
.|. :: VkExternalMemoryHandleTypeFlagsKHR
-> VkExternalMemoryHandleTypeFlagsKHR
-> VkExternalMemoryHandleTypeFlagsKHR
$c.|. :: VkExternalMemoryHandleTypeFlagsKHR
-> VkExternalMemoryHandleTypeFlagsKHR
-> VkExternalMemoryHandleTypeFlagsKHR
.&. :: VkExternalMemoryHandleTypeFlagsKHR
-> VkExternalMemoryHandleTypeFlagsKHR
-> VkExternalMemoryHandleTypeFlagsKHR
$c.&. :: VkExternalMemoryHandleTypeFlagsKHR
-> VkExternalMemoryHandleTypeFlagsKHR
-> VkExternalMemoryHandleTypeFlagsKHR
Bits, Bits VkExternalMemoryHandleTypeFlagsKHR
Bits VkExternalMemoryHandleTypeFlagsKHR
-> (VkExternalMemoryHandleTypeFlagsKHR -> Int)
-> (VkExternalMemoryHandleTypeFlagsKHR -> Int)
-> (VkExternalMemoryHandleTypeFlagsKHR -> Int)
-> FiniteBits VkExternalMemoryHandleTypeFlagsKHR
VkExternalMemoryHandleTypeFlagsKHR -> Int
forall b.
Bits b -> (b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
countTrailingZeros :: VkExternalMemoryHandleTypeFlagsKHR -> Int
$ccountTrailingZeros :: VkExternalMemoryHandleTypeFlagsKHR -> Int
countLeadingZeros :: VkExternalMemoryHandleTypeFlagsKHR -> Int
$ccountLeadingZeros :: VkExternalMemoryHandleTypeFlagsKHR -> Int
finiteBitSize :: VkExternalMemoryHandleTypeFlagsKHR -> Int
$cfiniteBitSize :: VkExternalMemoryHandleTypeFlagsKHR -> Int
FiniteBits, Ptr VkExternalMemoryHandleTypeFlagsKHR
-> IO VkExternalMemoryHandleTypeFlagsKHR
Ptr VkExternalMemoryHandleTypeFlagsKHR
-> Int -> IO VkExternalMemoryHandleTypeFlagsKHR
Ptr VkExternalMemoryHandleTypeFlagsKHR
-> Int -> VkExternalMemoryHandleTypeFlagsKHR -> IO ()
Ptr VkExternalMemoryHandleTypeFlagsKHR
-> VkExternalMemoryHandleTypeFlagsKHR -> IO ()
VkExternalMemoryHandleTypeFlagsKHR -> Int
(VkExternalMemoryHandleTypeFlagsKHR -> Int)
-> (VkExternalMemoryHandleTypeFlagsKHR -> Int)
-> (Ptr VkExternalMemoryHandleTypeFlagsKHR
    -> Int -> IO VkExternalMemoryHandleTypeFlagsKHR)
-> (Ptr VkExternalMemoryHandleTypeFlagsKHR
    -> Int -> VkExternalMemoryHandleTypeFlagsKHR -> IO ())
-> (forall b.
    Ptr b -> Int -> IO VkExternalMemoryHandleTypeFlagsKHR)
-> (forall b.
    Ptr b -> Int -> VkExternalMemoryHandleTypeFlagsKHR -> IO ())
-> (Ptr VkExternalMemoryHandleTypeFlagsKHR
    -> IO VkExternalMemoryHandleTypeFlagsKHR)
-> (Ptr VkExternalMemoryHandleTypeFlagsKHR
    -> VkExternalMemoryHandleTypeFlagsKHR -> IO ())
-> Storable VkExternalMemoryHandleTypeFlagsKHR
forall b. Ptr b -> Int -> IO VkExternalMemoryHandleTypeFlagsKHR
forall b.
Ptr b -> Int -> VkExternalMemoryHandleTypeFlagsKHR -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr VkExternalMemoryHandleTypeFlagsKHR
-> VkExternalMemoryHandleTypeFlagsKHR -> IO ()
$cpoke :: Ptr VkExternalMemoryHandleTypeFlagsKHR
-> VkExternalMemoryHandleTypeFlagsKHR -> IO ()
peek :: Ptr VkExternalMemoryHandleTypeFlagsKHR
-> IO VkExternalMemoryHandleTypeFlagsKHR
$cpeek :: Ptr VkExternalMemoryHandleTypeFlagsKHR
-> IO VkExternalMemoryHandleTypeFlagsKHR
pokeByteOff :: forall b.
Ptr b -> Int -> VkExternalMemoryHandleTypeFlagsKHR -> IO ()
$cpokeByteOff :: forall b.
Ptr b -> Int -> VkExternalMemoryHandleTypeFlagsKHR -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO VkExternalMemoryHandleTypeFlagsKHR
$cpeekByteOff :: forall b. Ptr b -> Int -> IO VkExternalMemoryHandleTypeFlagsKHR
pokeElemOff :: Ptr VkExternalMemoryHandleTypeFlagsKHR
-> Int -> VkExternalMemoryHandleTypeFlagsKHR -> IO ()
$cpokeElemOff :: Ptr VkExternalMemoryHandleTypeFlagsKHR
-> Int -> VkExternalMemoryHandleTypeFlagsKHR -> IO ()
peekElemOff :: Ptr VkExternalMemoryHandleTypeFlagsKHR
-> Int -> IO VkExternalMemoryHandleTypeFlagsKHR
$cpeekElemOff :: Ptr VkExternalMemoryHandleTypeFlagsKHR
-> Int -> IO VkExternalMemoryHandleTypeFlagsKHR
alignment :: VkExternalMemoryHandleTypeFlagsKHR -> Int
$calignment :: VkExternalMemoryHandleTypeFlagsKHR -> Int
sizeOf :: VkExternalMemoryHandleTypeFlagsKHR -> Int
$csizeOf :: VkExternalMemoryHandleTypeFlagsKHR -> Int
Storable)

instance Show VkExternalMemoryHandleTypeFlagsKHR where
    {-# INLINE showsPrec #-}
    showsPrec :: Int -> VkExternalMemoryHandleTypeFlagsKHR -> ShowS
showsPrec = (Int -> VkFlags -> ShowS)
-> Int -> VkExternalMemoryHandleTypeFlagsKHR -> ShowS
coerce (Int -> VkFlags -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec :: Int -> VkFlags -> ShowS)

instance Read VkExternalMemoryHandleTypeFlagsKHR where
    {-# INLINE readsPrec #-}
    readsPrec :: Int -> ReadS VkExternalMemoryHandleTypeFlagsKHR
readsPrec = (Int -> ReadS VkFlags)
-> Int -> ReadS VkExternalMemoryHandleTypeFlagsKHR
coerce (Int -> ReadS VkFlags
forall a. Read a => Int -> ReadS a
readsPrec :: Int -> ReadS VkFlags)

newtype VkExternalSemaphoreFeatureFlagsKHR = VkExternalSemaphoreFeatureFlagsKHR VkFlags
                                             deriving (VkExternalSemaphoreFeatureFlagsKHR
-> VkExternalSemaphoreFeatureFlagsKHR -> Bool
(VkExternalSemaphoreFeatureFlagsKHR
 -> VkExternalSemaphoreFeatureFlagsKHR -> Bool)
-> (VkExternalSemaphoreFeatureFlagsKHR
    -> VkExternalSemaphoreFeatureFlagsKHR -> Bool)
-> Eq VkExternalSemaphoreFeatureFlagsKHR
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VkExternalSemaphoreFeatureFlagsKHR
-> VkExternalSemaphoreFeatureFlagsKHR -> Bool
$c/= :: VkExternalSemaphoreFeatureFlagsKHR
-> VkExternalSemaphoreFeatureFlagsKHR -> Bool
== :: VkExternalSemaphoreFeatureFlagsKHR
-> VkExternalSemaphoreFeatureFlagsKHR -> Bool
$c== :: VkExternalSemaphoreFeatureFlagsKHR
-> VkExternalSemaphoreFeatureFlagsKHR -> Bool
Eq, Eq VkExternalSemaphoreFeatureFlagsKHR
Eq VkExternalSemaphoreFeatureFlagsKHR
-> (VkExternalSemaphoreFeatureFlagsKHR
    -> VkExternalSemaphoreFeatureFlagsKHR -> Ordering)
-> (VkExternalSemaphoreFeatureFlagsKHR
    -> VkExternalSemaphoreFeatureFlagsKHR -> Bool)
-> (VkExternalSemaphoreFeatureFlagsKHR
    -> VkExternalSemaphoreFeatureFlagsKHR -> Bool)
-> (VkExternalSemaphoreFeatureFlagsKHR
    -> VkExternalSemaphoreFeatureFlagsKHR -> Bool)
-> (VkExternalSemaphoreFeatureFlagsKHR
    -> VkExternalSemaphoreFeatureFlagsKHR -> Bool)
-> (VkExternalSemaphoreFeatureFlagsKHR
    -> VkExternalSemaphoreFeatureFlagsKHR
    -> VkExternalSemaphoreFeatureFlagsKHR)
-> (VkExternalSemaphoreFeatureFlagsKHR
    -> VkExternalSemaphoreFeatureFlagsKHR
    -> VkExternalSemaphoreFeatureFlagsKHR)
-> Ord VkExternalSemaphoreFeatureFlagsKHR
VkExternalSemaphoreFeatureFlagsKHR
-> VkExternalSemaphoreFeatureFlagsKHR -> Bool
VkExternalSemaphoreFeatureFlagsKHR
-> VkExternalSemaphoreFeatureFlagsKHR -> Ordering
VkExternalSemaphoreFeatureFlagsKHR
-> VkExternalSemaphoreFeatureFlagsKHR
-> VkExternalSemaphoreFeatureFlagsKHR
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: VkExternalSemaphoreFeatureFlagsKHR
-> VkExternalSemaphoreFeatureFlagsKHR
-> VkExternalSemaphoreFeatureFlagsKHR
$cmin :: VkExternalSemaphoreFeatureFlagsKHR
-> VkExternalSemaphoreFeatureFlagsKHR
-> VkExternalSemaphoreFeatureFlagsKHR
max :: VkExternalSemaphoreFeatureFlagsKHR
-> VkExternalSemaphoreFeatureFlagsKHR
-> VkExternalSemaphoreFeatureFlagsKHR
$cmax :: VkExternalSemaphoreFeatureFlagsKHR
-> VkExternalSemaphoreFeatureFlagsKHR
-> VkExternalSemaphoreFeatureFlagsKHR
>= :: VkExternalSemaphoreFeatureFlagsKHR
-> VkExternalSemaphoreFeatureFlagsKHR -> Bool
$c>= :: VkExternalSemaphoreFeatureFlagsKHR
-> VkExternalSemaphoreFeatureFlagsKHR -> Bool
> :: VkExternalSemaphoreFeatureFlagsKHR
-> VkExternalSemaphoreFeatureFlagsKHR -> Bool
$c> :: VkExternalSemaphoreFeatureFlagsKHR
-> VkExternalSemaphoreFeatureFlagsKHR -> Bool
<= :: VkExternalSemaphoreFeatureFlagsKHR
-> VkExternalSemaphoreFeatureFlagsKHR -> Bool
$c<= :: VkExternalSemaphoreFeatureFlagsKHR
-> VkExternalSemaphoreFeatureFlagsKHR -> Bool
< :: VkExternalSemaphoreFeatureFlagsKHR
-> VkExternalSemaphoreFeatureFlagsKHR -> Bool
$c< :: VkExternalSemaphoreFeatureFlagsKHR
-> VkExternalSemaphoreFeatureFlagsKHR -> Bool
compare :: VkExternalSemaphoreFeatureFlagsKHR
-> VkExternalSemaphoreFeatureFlagsKHR -> Ordering
$ccompare :: VkExternalSemaphoreFeatureFlagsKHR
-> VkExternalSemaphoreFeatureFlagsKHR -> Ordering
Ord, Int -> VkExternalSemaphoreFeatureFlagsKHR
VkExternalSemaphoreFeatureFlagsKHR -> Int
VkExternalSemaphoreFeatureFlagsKHR
-> [VkExternalSemaphoreFeatureFlagsKHR]
VkExternalSemaphoreFeatureFlagsKHR
-> VkExternalSemaphoreFeatureFlagsKHR
VkExternalSemaphoreFeatureFlagsKHR
-> VkExternalSemaphoreFeatureFlagsKHR
-> [VkExternalSemaphoreFeatureFlagsKHR]
VkExternalSemaphoreFeatureFlagsKHR
-> VkExternalSemaphoreFeatureFlagsKHR
-> VkExternalSemaphoreFeatureFlagsKHR
-> [VkExternalSemaphoreFeatureFlagsKHR]
(VkExternalSemaphoreFeatureFlagsKHR
 -> VkExternalSemaphoreFeatureFlagsKHR)
-> (VkExternalSemaphoreFeatureFlagsKHR
    -> VkExternalSemaphoreFeatureFlagsKHR)
-> (Int -> VkExternalSemaphoreFeatureFlagsKHR)
-> (VkExternalSemaphoreFeatureFlagsKHR -> Int)
-> (VkExternalSemaphoreFeatureFlagsKHR
    -> [VkExternalSemaphoreFeatureFlagsKHR])
-> (VkExternalSemaphoreFeatureFlagsKHR
    -> VkExternalSemaphoreFeatureFlagsKHR
    -> [VkExternalSemaphoreFeatureFlagsKHR])
-> (VkExternalSemaphoreFeatureFlagsKHR
    -> VkExternalSemaphoreFeatureFlagsKHR
    -> [VkExternalSemaphoreFeatureFlagsKHR])
-> (VkExternalSemaphoreFeatureFlagsKHR
    -> VkExternalSemaphoreFeatureFlagsKHR
    -> VkExternalSemaphoreFeatureFlagsKHR
    -> [VkExternalSemaphoreFeatureFlagsKHR])
-> Enum VkExternalSemaphoreFeatureFlagsKHR
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: VkExternalSemaphoreFeatureFlagsKHR
-> VkExternalSemaphoreFeatureFlagsKHR
-> VkExternalSemaphoreFeatureFlagsKHR
-> [VkExternalSemaphoreFeatureFlagsKHR]
$cenumFromThenTo :: VkExternalSemaphoreFeatureFlagsKHR
-> VkExternalSemaphoreFeatureFlagsKHR
-> VkExternalSemaphoreFeatureFlagsKHR
-> [VkExternalSemaphoreFeatureFlagsKHR]
enumFromTo :: VkExternalSemaphoreFeatureFlagsKHR
-> VkExternalSemaphoreFeatureFlagsKHR
-> [VkExternalSemaphoreFeatureFlagsKHR]
$cenumFromTo :: VkExternalSemaphoreFeatureFlagsKHR
-> VkExternalSemaphoreFeatureFlagsKHR
-> [VkExternalSemaphoreFeatureFlagsKHR]
enumFromThen :: VkExternalSemaphoreFeatureFlagsKHR
-> VkExternalSemaphoreFeatureFlagsKHR
-> [VkExternalSemaphoreFeatureFlagsKHR]
$cenumFromThen :: VkExternalSemaphoreFeatureFlagsKHR
-> VkExternalSemaphoreFeatureFlagsKHR
-> [VkExternalSemaphoreFeatureFlagsKHR]
enumFrom :: VkExternalSemaphoreFeatureFlagsKHR
-> [VkExternalSemaphoreFeatureFlagsKHR]
$cenumFrom :: VkExternalSemaphoreFeatureFlagsKHR
-> [VkExternalSemaphoreFeatureFlagsKHR]
fromEnum :: VkExternalSemaphoreFeatureFlagsKHR -> Int
$cfromEnum :: VkExternalSemaphoreFeatureFlagsKHR -> Int
toEnum :: Int -> VkExternalSemaphoreFeatureFlagsKHR
$ctoEnum :: Int -> VkExternalSemaphoreFeatureFlagsKHR
pred :: VkExternalSemaphoreFeatureFlagsKHR
-> VkExternalSemaphoreFeatureFlagsKHR
$cpred :: VkExternalSemaphoreFeatureFlagsKHR
-> VkExternalSemaphoreFeatureFlagsKHR
succ :: VkExternalSemaphoreFeatureFlagsKHR
-> VkExternalSemaphoreFeatureFlagsKHR
$csucc :: VkExternalSemaphoreFeatureFlagsKHR
-> VkExternalSemaphoreFeatureFlagsKHR
Enum, Eq VkExternalSemaphoreFeatureFlagsKHR
VkExternalSemaphoreFeatureFlagsKHR
Eq VkExternalSemaphoreFeatureFlagsKHR
-> (VkExternalSemaphoreFeatureFlagsKHR
    -> VkExternalSemaphoreFeatureFlagsKHR
    -> VkExternalSemaphoreFeatureFlagsKHR)
-> (VkExternalSemaphoreFeatureFlagsKHR
    -> VkExternalSemaphoreFeatureFlagsKHR
    -> VkExternalSemaphoreFeatureFlagsKHR)
-> (VkExternalSemaphoreFeatureFlagsKHR
    -> VkExternalSemaphoreFeatureFlagsKHR
    -> VkExternalSemaphoreFeatureFlagsKHR)
-> (VkExternalSemaphoreFeatureFlagsKHR
    -> VkExternalSemaphoreFeatureFlagsKHR)
-> (VkExternalSemaphoreFeatureFlagsKHR
    -> Int -> VkExternalSemaphoreFeatureFlagsKHR)
-> (VkExternalSemaphoreFeatureFlagsKHR
    -> Int -> VkExternalSemaphoreFeatureFlagsKHR)
-> VkExternalSemaphoreFeatureFlagsKHR
-> (Int -> VkExternalSemaphoreFeatureFlagsKHR)
-> (VkExternalSemaphoreFeatureFlagsKHR
    -> Int -> VkExternalSemaphoreFeatureFlagsKHR)
-> (VkExternalSemaphoreFeatureFlagsKHR
    -> Int -> VkExternalSemaphoreFeatureFlagsKHR)
-> (VkExternalSemaphoreFeatureFlagsKHR
    -> Int -> VkExternalSemaphoreFeatureFlagsKHR)
-> (VkExternalSemaphoreFeatureFlagsKHR -> Int -> Bool)
-> (VkExternalSemaphoreFeatureFlagsKHR -> Maybe Int)
-> (VkExternalSemaphoreFeatureFlagsKHR -> Int)
-> (VkExternalSemaphoreFeatureFlagsKHR -> Bool)
-> (VkExternalSemaphoreFeatureFlagsKHR
    -> Int -> VkExternalSemaphoreFeatureFlagsKHR)
-> (VkExternalSemaphoreFeatureFlagsKHR
    -> Int -> VkExternalSemaphoreFeatureFlagsKHR)
-> (VkExternalSemaphoreFeatureFlagsKHR
    -> Int -> VkExternalSemaphoreFeatureFlagsKHR)
-> (VkExternalSemaphoreFeatureFlagsKHR
    -> Int -> VkExternalSemaphoreFeatureFlagsKHR)
-> (VkExternalSemaphoreFeatureFlagsKHR
    -> Int -> VkExternalSemaphoreFeatureFlagsKHR)
-> (VkExternalSemaphoreFeatureFlagsKHR
    -> Int -> VkExternalSemaphoreFeatureFlagsKHR)
-> (VkExternalSemaphoreFeatureFlagsKHR -> Int)
-> Bits VkExternalSemaphoreFeatureFlagsKHR
Int -> VkExternalSemaphoreFeatureFlagsKHR
VkExternalSemaphoreFeatureFlagsKHR -> Bool
VkExternalSemaphoreFeatureFlagsKHR -> Int
VkExternalSemaphoreFeatureFlagsKHR -> Maybe Int
VkExternalSemaphoreFeatureFlagsKHR
-> VkExternalSemaphoreFeatureFlagsKHR
VkExternalSemaphoreFeatureFlagsKHR -> Int -> Bool
VkExternalSemaphoreFeatureFlagsKHR
-> Int -> VkExternalSemaphoreFeatureFlagsKHR
VkExternalSemaphoreFeatureFlagsKHR
-> VkExternalSemaphoreFeatureFlagsKHR
-> VkExternalSemaphoreFeatureFlagsKHR
forall a.
Eq a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
popCount :: VkExternalSemaphoreFeatureFlagsKHR -> Int
$cpopCount :: VkExternalSemaphoreFeatureFlagsKHR -> Int
rotateR :: VkExternalSemaphoreFeatureFlagsKHR
-> Int -> VkExternalSemaphoreFeatureFlagsKHR
$crotateR :: VkExternalSemaphoreFeatureFlagsKHR
-> Int -> VkExternalSemaphoreFeatureFlagsKHR
rotateL :: VkExternalSemaphoreFeatureFlagsKHR
-> Int -> VkExternalSemaphoreFeatureFlagsKHR
$crotateL :: VkExternalSemaphoreFeatureFlagsKHR
-> Int -> VkExternalSemaphoreFeatureFlagsKHR
unsafeShiftR :: VkExternalSemaphoreFeatureFlagsKHR
-> Int -> VkExternalSemaphoreFeatureFlagsKHR
$cunsafeShiftR :: VkExternalSemaphoreFeatureFlagsKHR
-> Int -> VkExternalSemaphoreFeatureFlagsKHR
shiftR :: VkExternalSemaphoreFeatureFlagsKHR
-> Int -> VkExternalSemaphoreFeatureFlagsKHR
$cshiftR :: VkExternalSemaphoreFeatureFlagsKHR
-> Int -> VkExternalSemaphoreFeatureFlagsKHR
unsafeShiftL :: VkExternalSemaphoreFeatureFlagsKHR
-> Int -> VkExternalSemaphoreFeatureFlagsKHR
$cunsafeShiftL :: VkExternalSemaphoreFeatureFlagsKHR
-> Int -> VkExternalSemaphoreFeatureFlagsKHR
shiftL :: VkExternalSemaphoreFeatureFlagsKHR
-> Int -> VkExternalSemaphoreFeatureFlagsKHR
$cshiftL :: VkExternalSemaphoreFeatureFlagsKHR
-> Int -> VkExternalSemaphoreFeatureFlagsKHR
isSigned :: VkExternalSemaphoreFeatureFlagsKHR -> Bool
$cisSigned :: VkExternalSemaphoreFeatureFlagsKHR -> Bool
bitSize :: VkExternalSemaphoreFeatureFlagsKHR -> Int
$cbitSize :: VkExternalSemaphoreFeatureFlagsKHR -> Int
bitSizeMaybe :: VkExternalSemaphoreFeatureFlagsKHR -> Maybe Int
$cbitSizeMaybe :: VkExternalSemaphoreFeatureFlagsKHR -> Maybe Int
testBit :: VkExternalSemaphoreFeatureFlagsKHR -> Int -> Bool
$ctestBit :: VkExternalSemaphoreFeatureFlagsKHR -> Int -> Bool
complementBit :: VkExternalSemaphoreFeatureFlagsKHR
-> Int -> VkExternalSemaphoreFeatureFlagsKHR
$ccomplementBit :: VkExternalSemaphoreFeatureFlagsKHR
-> Int -> VkExternalSemaphoreFeatureFlagsKHR
clearBit :: VkExternalSemaphoreFeatureFlagsKHR
-> Int -> VkExternalSemaphoreFeatureFlagsKHR
$cclearBit :: VkExternalSemaphoreFeatureFlagsKHR
-> Int -> VkExternalSemaphoreFeatureFlagsKHR
setBit :: VkExternalSemaphoreFeatureFlagsKHR
-> Int -> VkExternalSemaphoreFeatureFlagsKHR
$csetBit :: VkExternalSemaphoreFeatureFlagsKHR
-> Int -> VkExternalSemaphoreFeatureFlagsKHR
bit :: Int -> VkExternalSemaphoreFeatureFlagsKHR
$cbit :: Int -> VkExternalSemaphoreFeatureFlagsKHR
zeroBits :: VkExternalSemaphoreFeatureFlagsKHR
$czeroBits :: VkExternalSemaphoreFeatureFlagsKHR
rotate :: VkExternalSemaphoreFeatureFlagsKHR
-> Int -> VkExternalSemaphoreFeatureFlagsKHR
$crotate :: VkExternalSemaphoreFeatureFlagsKHR
-> Int -> VkExternalSemaphoreFeatureFlagsKHR
shift :: VkExternalSemaphoreFeatureFlagsKHR
-> Int -> VkExternalSemaphoreFeatureFlagsKHR
$cshift :: VkExternalSemaphoreFeatureFlagsKHR
-> Int -> VkExternalSemaphoreFeatureFlagsKHR
complement :: VkExternalSemaphoreFeatureFlagsKHR
-> VkExternalSemaphoreFeatureFlagsKHR
$ccomplement :: VkExternalSemaphoreFeatureFlagsKHR
-> VkExternalSemaphoreFeatureFlagsKHR
xor :: VkExternalSemaphoreFeatureFlagsKHR
-> VkExternalSemaphoreFeatureFlagsKHR
-> VkExternalSemaphoreFeatureFlagsKHR
$cxor :: VkExternalSemaphoreFeatureFlagsKHR
-> VkExternalSemaphoreFeatureFlagsKHR
-> VkExternalSemaphoreFeatureFlagsKHR
.|. :: VkExternalSemaphoreFeatureFlagsKHR
-> VkExternalSemaphoreFeatureFlagsKHR
-> VkExternalSemaphoreFeatureFlagsKHR
$c.|. :: VkExternalSemaphoreFeatureFlagsKHR
-> VkExternalSemaphoreFeatureFlagsKHR
-> VkExternalSemaphoreFeatureFlagsKHR
.&. :: VkExternalSemaphoreFeatureFlagsKHR
-> VkExternalSemaphoreFeatureFlagsKHR
-> VkExternalSemaphoreFeatureFlagsKHR
$c.&. :: VkExternalSemaphoreFeatureFlagsKHR
-> VkExternalSemaphoreFeatureFlagsKHR
-> VkExternalSemaphoreFeatureFlagsKHR
Bits, Bits VkExternalSemaphoreFeatureFlagsKHR
Bits VkExternalSemaphoreFeatureFlagsKHR
-> (VkExternalSemaphoreFeatureFlagsKHR -> Int)
-> (VkExternalSemaphoreFeatureFlagsKHR -> Int)
-> (VkExternalSemaphoreFeatureFlagsKHR -> Int)
-> FiniteBits VkExternalSemaphoreFeatureFlagsKHR
VkExternalSemaphoreFeatureFlagsKHR -> Int
forall b.
Bits b -> (b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
countTrailingZeros :: VkExternalSemaphoreFeatureFlagsKHR -> Int
$ccountTrailingZeros :: VkExternalSemaphoreFeatureFlagsKHR -> Int
countLeadingZeros :: VkExternalSemaphoreFeatureFlagsKHR -> Int
$ccountLeadingZeros :: VkExternalSemaphoreFeatureFlagsKHR -> Int
finiteBitSize :: VkExternalSemaphoreFeatureFlagsKHR -> Int
$cfiniteBitSize :: VkExternalSemaphoreFeatureFlagsKHR -> Int
FiniteBits, Ptr VkExternalSemaphoreFeatureFlagsKHR
-> IO VkExternalSemaphoreFeatureFlagsKHR
Ptr VkExternalSemaphoreFeatureFlagsKHR
-> Int -> IO VkExternalSemaphoreFeatureFlagsKHR
Ptr VkExternalSemaphoreFeatureFlagsKHR
-> Int -> VkExternalSemaphoreFeatureFlagsKHR -> IO ()
Ptr VkExternalSemaphoreFeatureFlagsKHR
-> VkExternalSemaphoreFeatureFlagsKHR -> IO ()
VkExternalSemaphoreFeatureFlagsKHR -> Int
(VkExternalSemaphoreFeatureFlagsKHR -> Int)
-> (VkExternalSemaphoreFeatureFlagsKHR -> Int)
-> (Ptr VkExternalSemaphoreFeatureFlagsKHR
    -> Int -> IO VkExternalSemaphoreFeatureFlagsKHR)
-> (Ptr VkExternalSemaphoreFeatureFlagsKHR
    -> Int -> VkExternalSemaphoreFeatureFlagsKHR -> IO ())
-> (forall b.
    Ptr b -> Int -> IO VkExternalSemaphoreFeatureFlagsKHR)
-> (forall b.
    Ptr b -> Int -> VkExternalSemaphoreFeatureFlagsKHR -> IO ())
-> (Ptr VkExternalSemaphoreFeatureFlagsKHR
    -> IO VkExternalSemaphoreFeatureFlagsKHR)
-> (Ptr VkExternalSemaphoreFeatureFlagsKHR
    -> VkExternalSemaphoreFeatureFlagsKHR -> IO ())
-> Storable VkExternalSemaphoreFeatureFlagsKHR
forall b. Ptr b -> Int -> IO VkExternalSemaphoreFeatureFlagsKHR
forall b.
Ptr b -> Int -> VkExternalSemaphoreFeatureFlagsKHR -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr VkExternalSemaphoreFeatureFlagsKHR
-> VkExternalSemaphoreFeatureFlagsKHR -> IO ()
$cpoke :: Ptr VkExternalSemaphoreFeatureFlagsKHR
-> VkExternalSemaphoreFeatureFlagsKHR -> IO ()
peek :: Ptr VkExternalSemaphoreFeatureFlagsKHR
-> IO VkExternalSemaphoreFeatureFlagsKHR
$cpeek :: Ptr VkExternalSemaphoreFeatureFlagsKHR
-> IO VkExternalSemaphoreFeatureFlagsKHR
pokeByteOff :: forall b.
Ptr b -> Int -> VkExternalSemaphoreFeatureFlagsKHR -> IO ()
$cpokeByteOff :: forall b.
Ptr b -> Int -> VkExternalSemaphoreFeatureFlagsKHR -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO VkExternalSemaphoreFeatureFlagsKHR
$cpeekByteOff :: forall b. Ptr b -> Int -> IO VkExternalSemaphoreFeatureFlagsKHR
pokeElemOff :: Ptr VkExternalSemaphoreFeatureFlagsKHR
-> Int -> VkExternalSemaphoreFeatureFlagsKHR -> IO ()
$cpokeElemOff :: Ptr VkExternalSemaphoreFeatureFlagsKHR
-> Int -> VkExternalSemaphoreFeatureFlagsKHR -> IO ()
peekElemOff :: Ptr VkExternalSemaphoreFeatureFlagsKHR
-> Int -> IO VkExternalSemaphoreFeatureFlagsKHR
$cpeekElemOff :: Ptr VkExternalSemaphoreFeatureFlagsKHR
-> Int -> IO VkExternalSemaphoreFeatureFlagsKHR
alignment :: VkExternalSemaphoreFeatureFlagsKHR -> Int
$calignment :: VkExternalSemaphoreFeatureFlagsKHR -> Int
sizeOf :: VkExternalSemaphoreFeatureFlagsKHR -> Int
$csizeOf :: VkExternalSemaphoreFeatureFlagsKHR -> Int
Storable)

instance Show VkExternalSemaphoreFeatureFlagsKHR where
    {-# INLINE showsPrec #-}
    showsPrec :: Int -> VkExternalSemaphoreFeatureFlagsKHR -> ShowS
showsPrec = (Int -> VkFlags -> ShowS)
-> Int -> VkExternalSemaphoreFeatureFlagsKHR -> ShowS
coerce (Int -> VkFlags -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec :: Int -> VkFlags -> ShowS)

instance Read VkExternalSemaphoreFeatureFlagsKHR where
    {-# INLINE readsPrec #-}
    readsPrec :: Int -> ReadS VkExternalSemaphoreFeatureFlagsKHR
readsPrec = (Int -> ReadS VkFlags)
-> Int -> ReadS VkExternalSemaphoreFeatureFlagsKHR
coerce (Int -> ReadS VkFlags
forall a. Read a => Int -> ReadS a
readsPrec :: Int -> ReadS VkFlags)

newtype VkExternalSemaphoreHandleTypeFlagsKHR = VkExternalSemaphoreHandleTypeFlagsKHR VkFlags
                                                deriving (VkExternalSemaphoreHandleTypeFlagsKHR
-> VkExternalSemaphoreHandleTypeFlagsKHR -> Bool
(VkExternalSemaphoreHandleTypeFlagsKHR
 -> VkExternalSemaphoreHandleTypeFlagsKHR -> Bool)
-> (VkExternalSemaphoreHandleTypeFlagsKHR
    -> VkExternalSemaphoreHandleTypeFlagsKHR -> Bool)
-> Eq VkExternalSemaphoreHandleTypeFlagsKHR
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VkExternalSemaphoreHandleTypeFlagsKHR
-> VkExternalSemaphoreHandleTypeFlagsKHR -> Bool
$c/= :: VkExternalSemaphoreHandleTypeFlagsKHR
-> VkExternalSemaphoreHandleTypeFlagsKHR -> Bool
== :: VkExternalSemaphoreHandleTypeFlagsKHR
-> VkExternalSemaphoreHandleTypeFlagsKHR -> Bool
$c== :: VkExternalSemaphoreHandleTypeFlagsKHR
-> VkExternalSemaphoreHandleTypeFlagsKHR -> Bool
Eq, Eq VkExternalSemaphoreHandleTypeFlagsKHR
Eq VkExternalSemaphoreHandleTypeFlagsKHR
-> (VkExternalSemaphoreHandleTypeFlagsKHR
    -> VkExternalSemaphoreHandleTypeFlagsKHR -> Ordering)
-> (VkExternalSemaphoreHandleTypeFlagsKHR
    -> VkExternalSemaphoreHandleTypeFlagsKHR -> Bool)
-> (VkExternalSemaphoreHandleTypeFlagsKHR
    -> VkExternalSemaphoreHandleTypeFlagsKHR -> Bool)
-> (VkExternalSemaphoreHandleTypeFlagsKHR
    -> VkExternalSemaphoreHandleTypeFlagsKHR -> Bool)
-> (VkExternalSemaphoreHandleTypeFlagsKHR
    -> VkExternalSemaphoreHandleTypeFlagsKHR -> Bool)
-> (VkExternalSemaphoreHandleTypeFlagsKHR
    -> VkExternalSemaphoreHandleTypeFlagsKHR
    -> VkExternalSemaphoreHandleTypeFlagsKHR)
-> (VkExternalSemaphoreHandleTypeFlagsKHR
    -> VkExternalSemaphoreHandleTypeFlagsKHR
    -> VkExternalSemaphoreHandleTypeFlagsKHR)
-> Ord VkExternalSemaphoreHandleTypeFlagsKHR
VkExternalSemaphoreHandleTypeFlagsKHR
-> VkExternalSemaphoreHandleTypeFlagsKHR -> Bool
VkExternalSemaphoreHandleTypeFlagsKHR
-> VkExternalSemaphoreHandleTypeFlagsKHR -> Ordering
VkExternalSemaphoreHandleTypeFlagsKHR
-> VkExternalSemaphoreHandleTypeFlagsKHR
-> VkExternalSemaphoreHandleTypeFlagsKHR
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: VkExternalSemaphoreHandleTypeFlagsKHR
-> VkExternalSemaphoreHandleTypeFlagsKHR
-> VkExternalSemaphoreHandleTypeFlagsKHR
$cmin :: VkExternalSemaphoreHandleTypeFlagsKHR
-> VkExternalSemaphoreHandleTypeFlagsKHR
-> VkExternalSemaphoreHandleTypeFlagsKHR
max :: VkExternalSemaphoreHandleTypeFlagsKHR
-> VkExternalSemaphoreHandleTypeFlagsKHR
-> VkExternalSemaphoreHandleTypeFlagsKHR
$cmax :: VkExternalSemaphoreHandleTypeFlagsKHR
-> VkExternalSemaphoreHandleTypeFlagsKHR
-> VkExternalSemaphoreHandleTypeFlagsKHR
>= :: VkExternalSemaphoreHandleTypeFlagsKHR
-> VkExternalSemaphoreHandleTypeFlagsKHR -> Bool
$c>= :: VkExternalSemaphoreHandleTypeFlagsKHR
-> VkExternalSemaphoreHandleTypeFlagsKHR -> Bool
> :: VkExternalSemaphoreHandleTypeFlagsKHR
-> VkExternalSemaphoreHandleTypeFlagsKHR -> Bool
$c> :: VkExternalSemaphoreHandleTypeFlagsKHR
-> VkExternalSemaphoreHandleTypeFlagsKHR -> Bool
<= :: VkExternalSemaphoreHandleTypeFlagsKHR
-> VkExternalSemaphoreHandleTypeFlagsKHR -> Bool
$c<= :: VkExternalSemaphoreHandleTypeFlagsKHR
-> VkExternalSemaphoreHandleTypeFlagsKHR -> Bool
< :: VkExternalSemaphoreHandleTypeFlagsKHR
-> VkExternalSemaphoreHandleTypeFlagsKHR -> Bool
$c< :: VkExternalSemaphoreHandleTypeFlagsKHR
-> VkExternalSemaphoreHandleTypeFlagsKHR -> Bool
compare :: VkExternalSemaphoreHandleTypeFlagsKHR
-> VkExternalSemaphoreHandleTypeFlagsKHR -> Ordering
$ccompare :: VkExternalSemaphoreHandleTypeFlagsKHR
-> VkExternalSemaphoreHandleTypeFlagsKHR -> Ordering
Ord, Int -> VkExternalSemaphoreHandleTypeFlagsKHR
VkExternalSemaphoreHandleTypeFlagsKHR -> Int
VkExternalSemaphoreHandleTypeFlagsKHR
-> [VkExternalSemaphoreHandleTypeFlagsKHR]
VkExternalSemaphoreHandleTypeFlagsKHR
-> VkExternalSemaphoreHandleTypeFlagsKHR
VkExternalSemaphoreHandleTypeFlagsKHR
-> VkExternalSemaphoreHandleTypeFlagsKHR
-> [VkExternalSemaphoreHandleTypeFlagsKHR]
VkExternalSemaphoreHandleTypeFlagsKHR
-> VkExternalSemaphoreHandleTypeFlagsKHR
-> VkExternalSemaphoreHandleTypeFlagsKHR
-> [VkExternalSemaphoreHandleTypeFlagsKHR]
(VkExternalSemaphoreHandleTypeFlagsKHR
 -> VkExternalSemaphoreHandleTypeFlagsKHR)
-> (VkExternalSemaphoreHandleTypeFlagsKHR
    -> VkExternalSemaphoreHandleTypeFlagsKHR)
-> (Int -> VkExternalSemaphoreHandleTypeFlagsKHR)
-> (VkExternalSemaphoreHandleTypeFlagsKHR -> Int)
-> (VkExternalSemaphoreHandleTypeFlagsKHR
    -> [VkExternalSemaphoreHandleTypeFlagsKHR])
-> (VkExternalSemaphoreHandleTypeFlagsKHR
    -> VkExternalSemaphoreHandleTypeFlagsKHR
    -> [VkExternalSemaphoreHandleTypeFlagsKHR])
-> (VkExternalSemaphoreHandleTypeFlagsKHR
    -> VkExternalSemaphoreHandleTypeFlagsKHR
    -> [VkExternalSemaphoreHandleTypeFlagsKHR])
-> (VkExternalSemaphoreHandleTypeFlagsKHR
    -> VkExternalSemaphoreHandleTypeFlagsKHR
    -> VkExternalSemaphoreHandleTypeFlagsKHR
    -> [VkExternalSemaphoreHandleTypeFlagsKHR])
-> Enum VkExternalSemaphoreHandleTypeFlagsKHR
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: VkExternalSemaphoreHandleTypeFlagsKHR
-> VkExternalSemaphoreHandleTypeFlagsKHR
-> VkExternalSemaphoreHandleTypeFlagsKHR
-> [VkExternalSemaphoreHandleTypeFlagsKHR]
$cenumFromThenTo :: VkExternalSemaphoreHandleTypeFlagsKHR
-> VkExternalSemaphoreHandleTypeFlagsKHR
-> VkExternalSemaphoreHandleTypeFlagsKHR
-> [VkExternalSemaphoreHandleTypeFlagsKHR]
enumFromTo :: VkExternalSemaphoreHandleTypeFlagsKHR
-> VkExternalSemaphoreHandleTypeFlagsKHR
-> [VkExternalSemaphoreHandleTypeFlagsKHR]
$cenumFromTo :: VkExternalSemaphoreHandleTypeFlagsKHR
-> VkExternalSemaphoreHandleTypeFlagsKHR
-> [VkExternalSemaphoreHandleTypeFlagsKHR]
enumFromThen :: VkExternalSemaphoreHandleTypeFlagsKHR
-> VkExternalSemaphoreHandleTypeFlagsKHR
-> [VkExternalSemaphoreHandleTypeFlagsKHR]
$cenumFromThen :: VkExternalSemaphoreHandleTypeFlagsKHR
-> VkExternalSemaphoreHandleTypeFlagsKHR
-> [VkExternalSemaphoreHandleTypeFlagsKHR]
enumFrom :: VkExternalSemaphoreHandleTypeFlagsKHR
-> [VkExternalSemaphoreHandleTypeFlagsKHR]
$cenumFrom :: VkExternalSemaphoreHandleTypeFlagsKHR
-> [VkExternalSemaphoreHandleTypeFlagsKHR]
fromEnum :: VkExternalSemaphoreHandleTypeFlagsKHR -> Int
$cfromEnum :: VkExternalSemaphoreHandleTypeFlagsKHR -> Int
toEnum :: Int -> VkExternalSemaphoreHandleTypeFlagsKHR
$ctoEnum :: Int -> VkExternalSemaphoreHandleTypeFlagsKHR
pred :: VkExternalSemaphoreHandleTypeFlagsKHR
-> VkExternalSemaphoreHandleTypeFlagsKHR
$cpred :: VkExternalSemaphoreHandleTypeFlagsKHR
-> VkExternalSemaphoreHandleTypeFlagsKHR
succ :: VkExternalSemaphoreHandleTypeFlagsKHR
-> VkExternalSemaphoreHandleTypeFlagsKHR
$csucc :: VkExternalSemaphoreHandleTypeFlagsKHR
-> VkExternalSemaphoreHandleTypeFlagsKHR
Enum, Eq VkExternalSemaphoreHandleTypeFlagsKHR
VkExternalSemaphoreHandleTypeFlagsKHR
Eq VkExternalSemaphoreHandleTypeFlagsKHR
-> (VkExternalSemaphoreHandleTypeFlagsKHR
    -> VkExternalSemaphoreHandleTypeFlagsKHR
    -> VkExternalSemaphoreHandleTypeFlagsKHR)
-> (VkExternalSemaphoreHandleTypeFlagsKHR
    -> VkExternalSemaphoreHandleTypeFlagsKHR
    -> VkExternalSemaphoreHandleTypeFlagsKHR)
-> (VkExternalSemaphoreHandleTypeFlagsKHR
    -> VkExternalSemaphoreHandleTypeFlagsKHR
    -> VkExternalSemaphoreHandleTypeFlagsKHR)
-> (VkExternalSemaphoreHandleTypeFlagsKHR
    -> VkExternalSemaphoreHandleTypeFlagsKHR)
-> (VkExternalSemaphoreHandleTypeFlagsKHR
    -> Int -> VkExternalSemaphoreHandleTypeFlagsKHR)
-> (VkExternalSemaphoreHandleTypeFlagsKHR
    -> Int -> VkExternalSemaphoreHandleTypeFlagsKHR)
-> VkExternalSemaphoreHandleTypeFlagsKHR
-> (Int -> VkExternalSemaphoreHandleTypeFlagsKHR)
-> (VkExternalSemaphoreHandleTypeFlagsKHR
    -> Int -> VkExternalSemaphoreHandleTypeFlagsKHR)
-> (VkExternalSemaphoreHandleTypeFlagsKHR
    -> Int -> VkExternalSemaphoreHandleTypeFlagsKHR)
-> (VkExternalSemaphoreHandleTypeFlagsKHR
    -> Int -> VkExternalSemaphoreHandleTypeFlagsKHR)
-> (VkExternalSemaphoreHandleTypeFlagsKHR -> Int -> Bool)
-> (VkExternalSemaphoreHandleTypeFlagsKHR -> Maybe Int)
-> (VkExternalSemaphoreHandleTypeFlagsKHR -> Int)
-> (VkExternalSemaphoreHandleTypeFlagsKHR -> Bool)
-> (VkExternalSemaphoreHandleTypeFlagsKHR
    -> Int -> VkExternalSemaphoreHandleTypeFlagsKHR)
-> (VkExternalSemaphoreHandleTypeFlagsKHR
    -> Int -> VkExternalSemaphoreHandleTypeFlagsKHR)
-> (VkExternalSemaphoreHandleTypeFlagsKHR
    -> Int -> VkExternalSemaphoreHandleTypeFlagsKHR)
-> (VkExternalSemaphoreHandleTypeFlagsKHR
    -> Int -> VkExternalSemaphoreHandleTypeFlagsKHR)
-> (VkExternalSemaphoreHandleTypeFlagsKHR
    -> Int -> VkExternalSemaphoreHandleTypeFlagsKHR)
-> (VkExternalSemaphoreHandleTypeFlagsKHR
    -> Int -> VkExternalSemaphoreHandleTypeFlagsKHR)
-> (VkExternalSemaphoreHandleTypeFlagsKHR -> Int)
-> Bits VkExternalSemaphoreHandleTypeFlagsKHR
Int -> VkExternalSemaphoreHandleTypeFlagsKHR
VkExternalSemaphoreHandleTypeFlagsKHR -> Bool
VkExternalSemaphoreHandleTypeFlagsKHR -> Int
VkExternalSemaphoreHandleTypeFlagsKHR -> Maybe Int
VkExternalSemaphoreHandleTypeFlagsKHR
-> VkExternalSemaphoreHandleTypeFlagsKHR
VkExternalSemaphoreHandleTypeFlagsKHR -> Int -> Bool
VkExternalSemaphoreHandleTypeFlagsKHR
-> Int -> VkExternalSemaphoreHandleTypeFlagsKHR
VkExternalSemaphoreHandleTypeFlagsKHR
-> VkExternalSemaphoreHandleTypeFlagsKHR
-> VkExternalSemaphoreHandleTypeFlagsKHR
forall a.
Eq a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
popCount :: VkExternalSemaphoreHandleTypeFlagsKHR -> Int
$cpopCount :: VkExternalSemaphoreHandleTypeFlagsKHR -> Int
rotateR :: VkExternalSemaphoreHandleTypeFlagsKHR
-> Int -> VkExternalSemaphoreHandleTypeFlagsKHR
$crotateR :: VkExternalSemaphoreHandleTypeFlagsKHR
-> Int -> VkExternalSemaphoreHandleTypeFlagsKHR
rotateL :: VkExternalSemaphoreHandleTypeFlagsKHR
-> Int -> VkExternalSemaphoreHandleTypeFlagsKHR
$crotateL :: VkExternalSemaphoreHandleTypeFlagsKHR
-> Int -> VkExternalSemaphoreHandleTypeFlagsKHR
unsafeShiftR :: VkExternalSemaphoreHandleTypeFlagsKHR
-> Int -> VkExternalSemaphoreHandleTypeFlagsKHR
$cunsafeShiftR :: VkExternalSemaphoreHandleTypeFlagsKHR
-> Int -> VkExternalSemaphoreHandleTypeFlagsKHR
shiftR :: VkExternalSemaphoreHandleTypeFlagsKHR
-> Int -> VkExternalSemaphoreHandleTypeFlagsKHR
$cshiftR :: VkExternalSemaphoreHandleTypeFlagsKHR
-> Int -> VkExternalSemaphoreHandleTypeFlagsKHR
unsafeShiftL :: VkExternalSemaphoreHandleTypeFlagsKHR
-> Int -> VkExternalSemaphoreHandleTypeFlagsKHR
$cunsafeShiftL :: VkExternalSemaphoreHandleTypeFlagsKHR
-> Int -> VkExternalSemaphoreHandleTypeFlagsKHR
shiftL :: VkExternalSemaphoreHandleTypeFlagsKHR
-> Int -> VkExternalSemaphoreHandleTypeFlagsKHR
$cshiftL :: VkExternalSemaphoreHandleTypeFlagsKHR
-> Int -> VkExternalSemaphoreHandleTypeFlagsKHR
isSigned :: VkExternalSemaphoreHandleTypeFlagsKHR -> Bool
$cisSigned :: VkExternalSemaphoreHandleTypeFlagsKHR -> Bool
bitSize :: VkExternalSemaphoreHandleTypeFlagsKHR -> Int
$cbitSize :: VkExternalSemaphoreHandleTypeFlagsKHR -> Int
bitSizeMaybe :: VkExternalSemaphoreHandleTypeFlagsKHR -> Maybe Int
$cbitSizeMaybe :: VkExternalSemaphoreHandleTypeFlagsKHR -> Maybe Int
testBit :: VkExternalSemaphoreHandleTypeFlagsKHR -> Int -> Bool
$ctestBit :: VkExternalSemaphoreHandleTypeFlagsKHR -> Int -> Bool
complementBit :: VkExternalSemaphoreHandleTypeFlagsKHR
-> Int -> VkExternalSemaphoreHandleTypeFlagsKHR
$ccomplementBit :: VkExternalSemaphoreHandleTypeFlagsKHR
-> Int -> VkExternalSemaphoreHandleTypeFlagsKHR
clearBit :: VkExternalSemaphoreHandleTypeFlagsKHR
-> Int -> VkExternalSemaphoreHandleTypeFlagsKHR
$cclearBit :: VkExternalSemaphoreHandleTypeFlagsKHR
-> Int -> VkExternalSemaphoreHandleTypeFlagsKHR
setBit :: VkExternalSemaphoreHandleTypeFlagsKHR
-> Int -> VkExternalSemaphoreHandleTypeFlagsKHR
$csetBit :: VkExternalSemaphoreHandleTypeFlagsKHR
-> Int -> VkExternalSemaphoreHandleTypeFlagsKHR
bit :: Int -> VkExternalSemaphoreHandleTypeFlagsKHR
$cbit :: Int -> VkExternalSemaphoreHandleTypeFlagsKHR
zeroBits :: VkExternalSemaphoreHandleTypeFlagsKHR
$czeroBits :: VkExternalSemaphoreHandleTypeFlagsKHR
rotate :: VkExternalSemaphoreHandleTypeFlagsKHR
-> Int -> VkExternalSemaphoreHandleTypeFlagsKHR
$crotate :: VkExternalSemaphoreHandleTypeFlagsKHR
-> Int -> VkExternalSemaphoreHandleTypeFlagsKHR
shift :: VkExternalSemaphoreHandleTypeFlagsKHR
-> Int -> VkExternalSemaphoreHandleTypeFlagsKHR
$cshift :: VkExternalSemaphoreHandleTypeFlagsKHR
-> Int -> VkExternalSemaphoreHandleTypeFlagsKHR
complement :: VkExternalSemaphoreHandleTypeFlagsKHR
-> VkExternalSemaphoreHandleTypeFlagsKHR
$ccomplement :: VkExternalSemaphoreHandleTypeFlagsKHR
-> VkExternalSemaphoreHandleTypeFlagsKHR
xor :: VkExternalSemaphoreHandleTypeFlagsKHR
-> VkExternalSemaphoreHandleTypeFlagsKHR
-> VkExternalSemaphoreHandleTypeFlagsKHR
$cxor :: VkExternalSemaphoreHandleTypeFlagsKHR
-> VkExternalSemaphoreHandleTypeFlagsKHR
-> VkExternalSemaphoreHandleTypeFlagsKHR
.|. :: VkExternalSemaphoreHandleTypeFlagsKHR
-> VkExternalSemaphoreHandleTypeFlagsKHR
-> VkExternalSemaphoreHandleTypeFlagsKHR
$c.|. :: VkExternalSemaphoreHandleTypeFlagsKHR
-> VkExternalSemaphoreHandleTypeFlagsKHR
-> VkExternalSemaphoreHandleTypeFlagsKHR
.&. :: VkExternalSemaphoreHandleTypeFlagsKHR
-> VkExternalSemaphoreHandleTypeFlagsKHR
-> VkExternalSemaphoreHandleTypeFlagsKHR
$c.&. :: VkExternalSemaphoreHandleTypeFlagsKHR
-> VkExternalSemaphoreHandleTypeFlagsKHR
-> VkExternalSemaphoreHandleTypeFlagsKHR
Bits, Bits VkExternalSemaphoreHandleTypeFlagsKHR
Bits VkExternalSemaphoreHandleTypeFlagsKHR
-> (VkExternalSemaphoreHandleTypeFlagsKHR -> Int)
-> (VkExternalSemaphoreHandleTypeFlagsKHR -> Int)
-> (VkExternalSemaphoreHandleTypeFlagsKHR -> Int)
-> FiniteBits VkExternalSemaphoreHandleTypeFlagsKHR
VkExternalSemaphoreHandleTypeFlagsKHR -> Int
forall b.
Bits b -> (b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
countTrailingZeros :: VkExternalSemaphoreHandleTypeFlagsKHR -> Int
$ccountTrailingZeros :: VkExternalSemaphoreHandleTypeFlagsKHR -> Int
countLeadingZeros :: VkExternalSemaphoreHandleTypeFlagsKHR -> Int
$ccountLeadingZeros :: VkExternalSemaphoreHandleTypeFlagsKHR -> Int
finiteBitSize :: VkExternalSemaphoreHandleTypeFlagsKHR -> Int
$cfiniteBitSize :: VkExternalSemaphoreHandleTypeFlagsKHR -> Int
FiniteBits, Ptr VkExternalSemaphoreHandleTypeFlagsKHR
-> IO VkExternalSemaphoreHandleTypeFlagsKHR
Ptr VkExternalSemaphoreHandleTypeFlagsKHR
-> Int -> IO VkExternalSemaphoreHandleTypeFlagsKHR
Ptr VkExternalSemaphoreHandleTypeFlagsKHR
-> Int -> VkExternalSemaphoreHandleTypeFlagsKHR -> IO ()
Ptr VkExternalSemaphoreHandleTypeFlagsKHR
-> VkExternalSemaphoreHandleTypeFlagsKHR -> IO ()
VkExternalSemaphoreHandleTypeFlagsKHR -> Int
(VkExternalSemaphoreHandleTypeFlagsKHR -> Int)
-> (VkExternalSemaphoreHandleTypeFlagsKHR -> Int)
-> (Ptr VkExternalSemaphoreHandleTypeFlagsKHR
    -> Int -> IO VkExternalSemaphoreHandleTypeFlagsKHR)
-> (Ptr VkExternalSemaphoreHandleTypeFlagsKHR
    -> Int -> VkExternalSemaphoreHandleTypeFlagsKHR -> IO ())
-> (forall b.
    Ptr b -> Int -> IO VkExternalSemaphoreHandleTypeFlagsKHR)
-> (forall b.
    Ptr b -> Int -> VkExternalSemaphoreHandleTypeFlagsKHR -> IO ())
-> (Ptr VkExternalSemaphoreHandleTypeFlagsKHR
    -> IO VkExternalSemaphoreHandleTypeFlagsKHR)
-> (Ptr VkExternalSemaphoreHandleTypeFlagsKHR
    -> VkExternalSemaphoreHandleTypeFlagsKHR -> IO ())
-> Storable VkExternalSemaphoreHandleTypeFlagsKHR
forall b. Ptr b -> Int -> IO VkExternalSemaphoreHandleTypeFlagsKHR
forall b.
Ptr b -> Int -> VkExternalSemaphoreHandleTypeFlagsKHR -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr VkExternalSemaphoreHandleTypeFlagsKHR
-> VkExternalSemaphoreHandleTypeFlagsKHR -> IO ()
$cpoke :: Ptr VkExternalSemaphoreHandleTypeFlagsKHR
-> VkExternalSemaphoreHandleTypeFlagsKHR -> IO ()
peek :: Ptr VkExternalSemaphoreHandleTypeFlagsKHR
-> IO VkExternalSemaphoreHandleTypeFlagsKHR
$cpeek :: Ptr VkExternalSemaphoreHandleTypeFlagsKHR
-> IO VkExternalSemaphoreHandleTypeFlagsKHR
pokeByteOff :: forall b.
Ptr b -> Int -> VkExternalSemaphoreHandleTypeFlagsKHR -> IO ()
$cpokeByteOff :: forall b.
Ptr b -> Int -> VkExternalSemaphoreHandleTypeFlagsKHR -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO VkExternalSemaphoreHandleTypeFlagsKHR
$cpeekByteOff :: forall b. Ptr b -> Int -> IO VkExternalSemaphoreHandleTypeFlagsKHR
pokeElemOff :: Ptr VkExternalSemaphoreHandleTypeFlagsKHR
-> Int -> VkExternalSemaphoreHandleTypeFlagsKHR -> IO ()
$cpokeElemOff :: Ptr VkExternalSemaphoreHandleTypeFlagsKHR
-> Int -> VkExternalSemaphoreHandleTypeFlagsKHR -> IO ()
peekElemOff :: Ptr VkExternalSemaphoreHandleTypeFlagsKHR
-> Int -> IO VkExternalSemaphoreHandleTypeFlagsKHR
$cpeekElemOff :: Ptr VkExternalSemaphoreHandleTypeFlagsKHR
-> Int -> IO VkExternalSemaphoreHandleTypeFlagsKHR
alignment :: VkExternalSemaphoreHandleTypeFlagsKHR -> Int
$calignment :: VkExternalSemaphoreHandleTypeFlagsKHR -> Int
sizeOf :: VkExternalSemaphoreHandleTypeFlagsKHR -> Int
$csizeOf :: VkExternalSemaphoreHandleTypeFlagsKHR -> Int
Storable)

instance Show VkExternalSemaphoreHandleTypeFlagsKHR where
    {-# INLINE showsPrec #-}
    showsPrec :: Int -> VkExternalSemaphoreHandleTypeFlagsKHR -> ShowS
showsPrec = (Int -> VkFlags -> ShowS)
-> Int -> VkExternalSemaphoreHandleTypeFlagsKHR -> ShowS
coerce (Int -> VkFlags -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec :: Int -> VkFlags -> ShowS)

instance Read VkExternalSemaphoreHandleTypeFlagsKHR where
    {-# INLINE readsPrec #-}
    readsPrec :: Int -> ReadS VkExternalSemaphoreHandleTypeFlagsKHR
readsPrec = (Int -> ReadS VkFlags)
-> Int -> ReadS VkExternalSemaphoreHandleTypeFlagsKHR
coerce (Int -> ReadS VkFlags
forall a. Read a => Int -> ReadS a
readsPrec :: Int -> ReadS VkFlags)

newtype VkFenceImportFlagsKHR = VkFenceImportFlagsKHR VkFlags
                                deriving (VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR -> Bool
(VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR -> Bool)
-> (VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR -> Bool)
-> Eq VkFenceImportFlagsKHR
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR -> Bool
$c/= :: VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR -> Bool
== :: VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR -> Bool
$c== :: VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR -> Bool
Eq, Eq VkFenceImportFlagsKHR
Eq VkFenceImportFlagsKHR
-> (VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR -> Ordering)
-> (VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR -> Bool)
-> (VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR -> Bool)
-> (VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR -> Bool)
-> (VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR -> Bool)
-> (VkFenceImportFlagsKHR
    -> VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR)
-> (VkFenceImportFlagsKHR
    -> VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR)
-> Ord VkFenceImportFlagsKHR
VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR -> Bool
VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR -> Ordering
VkFenceImportFlagsKHR
-> VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: VkFenceImportFlagsKHR
-> VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR
$cmin :: VkFenceImportFlagsKHR
-> VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR
max :: VkFenceImportFlagsKHR
-> VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR
$cmax :: VkFenceImportFlagsKHR
-> VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR
>= :: VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR -> Bool
$c>= :: VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR -> Bool
> :: VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR -> Bool
$c> :: VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR -> Bool
<= :: VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR -> Bool
$c<= :: VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR -> Bool
< :: VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR -> Bool
$c< :: VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR -> Bool
compare :: VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR -> Ordering
$ccompare :: VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR -> Ordering
Ord, Int -> VkFenceImportFlagsKHR
VkFenceImportFlagsKHR -> Int
VkFenceImportFlagsKHR -> [VkFenceImportFlagsKHR]
VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR
VkFenceImportFlagsKHR
-> VkFenceImportFlagsKHR -> [VkFenceImportFlagsKHR]
VkFenceImportFlagsKHR
-> VkFenceImportFlagsKHR
-> VkFenceImportFlagsKHR
-> [VkFenceImportFlagsKHR]
(VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR)
-> (VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR)
-> (Int -> VkFenceImportFlagsKHR)
-> (VkFenceImportFlagsKHR -> Int)
-> (VkFenceImportFlagsKHR -> [VkFenceImportFlagsKHR])
-> (VkFenceImportFlagsKHR
    -> VkFenceImportFlagsKHR -> [VkFenceImportFlagsKHR])
-> (VkFenceImportFlagsKHR
    -> VkFenceImportFlagsKHR -> [VkFenceImportFlagsKHR])
-> (VkFenceImportFlagsKHR
    -> VkFenceImportFlagsKHR
    -> VkFenceImportFlagsKHR
    -> [VkFenceImportFlagsKHR])
-> Enum VkFenceImportFlagsKHR
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: VkFenceImportFlagsKHR
-> VkFenceImportFlagsKHR
-> VkFenceImportFlagsKHR
-> [VkFenceImportFlagsKHR]
$cenumFromThenTo :: VkFenceImportFlagsKHR
-> VkFenceImportFlagsKHR
-> VkFenceImportFlagsKHR
-> [VkFenceImportFlagsKHR]
enumFromTo :: VkFenceImportFlagsKHR
-> VkFenceImportFlagsKHR -> [VkFenceImportFlagsKHR]
$cenumFromTo :: VkFenceImportFlagsKHR
-> VkFenceImportFlagsKHR -> [VkFenceImportFlagsKHR]
enumFromThen :: VkFenceImportFlagsKHR
-> VkFenceImportFlagsKHR -> [VkFenceImportFlagsKHR]
$cenumFromThen :: VkFenceImportFlagsKHR
-> VkFenceImportFlagsKHR -> [VkFenceImportFlagsKHR]
enumFrom :: VkFenceImportFlagsKHR -> [VkFenceImportFlagsKHR]
$cenumFrom :: VkFenceImportFlagsKHR -> [VkFenceImportFlagsKHR]
fromEnum :: VkFenceImportFlagsKHR -> Int
$cfromEnum :: VkFenceImportFlagsKHR -> Int
toEnum :: Int -> VkFenceImportFlagsKHR
$ctoEnum :: Int -> VkFenceImportFlagsKHR
pred :: VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR
$cpred :: VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR
succ :: VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR
$csucc :: VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR
Enum, Eq VkFenceImportFlagsKHR
VkFenceImportFlagsKHR
Eq VkFenceImportFlagsKHR
-> (VkFenceImportFlagsKHR
    -> VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR)
-> (VkFenceImportFlagsKHR
    -> VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR)
-> (VkFenceImportFlagsKHR
    -> VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR)
-> (VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR)
-> (VkFenceImportFlagsKHR -> Int -> VkFenceImportFlagsKHR)
-> (VkFenceImportFlagsKHR -> Int -> VkFenceImportFlagsKHR)
-> VkFenceImportFlagsKHR
-> (Int -> VkFenceImportFlagsKHR)
-> (VkFenceImportFlagsKHR -> Int -> VkFenceImportFlagsKHR)
-> (VkFenceImportFlagsKHR -> Int -> VkFenceImportFlagsKHR)
-> (VkFenceImportFlagsKHR -> Int -> VkFenceImportFlagsKHR)
-> (VkFenceImportFlagsKHR -> Int -> Bool)
-> (VkFenceImportFlagsKHR -> Maybe Int)
-> (VkFenceImportFlagsKHR -> Int)
-> (VkFenceImportFlagsKHR -> Bool)
-> (VkFenceImportFlagsKHR -> Int -> VkFenceImportFlagsKHR)
-> (VkFenceImportFlagsKHR -> Int -> VkFenceImportFlagsKHR)
-> (VkFenceImportFlagsKHR -> Int -> VkFenceImportFlagsKHR)
-> (VkFenceImportFlagsKHR -> Int -> VkFenceImportFlagsKHR)
-> (VkFenceImportFlagsKHR -> Int -> VkFenceImportFlagsKHR)
-> (VkFenceImportFlagsKHR -> Int -> VkFenceImportFlagsKHR)
-> (VkFenceImportFlagsKHR -> Int)
-> Bits VkFenceImportFlagsKHR
Int -> VkFenceImportFlagsKHR
VkFenceImportFlagsKHR -> Bool
VkFenceImportFlagsKHR -> Int
VkFenceImportFlagsKHR -> Maybe Int
VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR
VkFenceImportFlagsKHR -> Int -> Bool
VkFenceImportFlagsKHR -> Int -> VkFenceImportFlagsKHR
VkFenceImportFlagsKHR
-> VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR
forall a.
Eq a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
popCount :: VkFenceImportFlagsKHR -> Int
$cpopCount :: VkFenceImportFlagsKHR -> Int
rotateR :: VkFenceImportFlagsKHR -> Int -> VkFenceImportFlagsKHR
$crotateR :: VkFenceImportFlagsKHR -> Int -> VkFenceImportFlagsKHR
rotateL :: VkFenceImportFlagsKHR -> Int -> VkFenceImportFlagsKHR
$crotateL :: VkFenceImportFlagsKHR -> Int -> VkFenceImportFlagsKHR
unsafeShiftR :: VkFenceImportFlagsKHR -> Int -> VkFenceImportFlagsKHR
$cunsafeShiftR :: VkFenceImportFlagsKHR -> Int -> VkFenceImportFlagsKHR
shiftR :: VkFenceImportFlagsKHR -> Int -> VkFenceImportFlagsKHR
$cshiftR :: VkFenceImportFlagsKHR -> Int -> VkFenceImportFlagsKHR
unsafeShiftL :: VkFenceImportFlagsKHR -> Int -> VkFenceImportFlagsKHR
$cunsafeShiftL :: VkFenceImportFlagsKHR -> Int -> VkFenceImportFlagsKHR
shiftL :: VkFenceImportFlagsKHR -> Int -> VkFenceImportFlagsKHR
$cshiftL :: VkFenceImportFlagsKHR -> Int -> VkFenceImportFlagsKHR
isSigned :: VkFenceImportFlagsKHR -> Bool
$cisSigned :: VkFenceImportFlagsKHR -> Bool
bitSize :: VkFenceImportFlagsKHR -> Int
$cbitSize :: VkFenceImportFlagsKHR -> Int
bitSizeMaybe :: VkFenceImportFlagsKHR -> Maybe Int
$cbitSizeMaybe :: VkFenceImportFlagsKHR -> Maybe Int
testBit :: VkFenceImportFlagsKHR -> Int -> Bool
$ctestBit :: VkFenceImportFlagsKHR -> Int -> Bool
complementBit :: VkFenceImportFlagsKHR -> Int -> VkFenceImportFlagsKHR
$ccomplementBit :: VkFenceImportFlagsKHR -> Int -> VkFenceImportFlagsKHR
clearBit :: VkFenceImportFlagsKHR -> Int -> VkFenceImportFlagsKHR
$cclearBit :: VkFenceImportFlagsKHR -> Int -> VkFenceImportFlagsKHR
setBit :: VkFenceImportFlagsKHR -> Int -> VkFenceImportFlagsKHR
$csetBit :: VkFenceImportFlagsKHR -> Int -> VkFenceImportFlagsKHR
bit :: Int -> VkFenceImportFlagsKHR
$cbit :: Int -> VkFenceImportFlagsKHR
zeroBits :: VkFenceImportFlagsKHR
$czeroBits :: VkFenceImportFlagsKHR
rotate :: VkFenceImportFlagsKHR -> Int -> VkFenceImportFlagsKHR
$crotate :: VkFenceImportFlagsKHR -> Int -> VkFenceImportFlagsKHR
shift :: VkFenceImportFlagsKHR -> Int -> VkFenceImportFlagsKHR
$cshift :: VkFenceImportFlagsKHR -> Int -> VkFenceImportFlagsKHR
complement :: VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR
$ccomplement :: VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR
xor :: VkFenceImportFlagsKHR
-> VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR
$cxor :: VkFenceImportFlagsKHR
-> VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR
.|. :: VkFenceImportFlagsKHR
-> VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR
$c.|. :: VkFenceImportFlagsKHR
-> VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR
.&. :: VkFenceImportFlagsKHR
-> VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR
$c.&. :: VkFenceImportFlagsKHR
-> VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR
Bits, Bits VkFenceImportFlagsKHR
Bits VkFenceImportFlagsKHR
-> (VkFenceImportFlagsKHR -> Int)
-> (VkFenceImportFlagsKHR -> Int)
-> (VkFenceImportFlagsKHR -> Int)
-> FiniteBits VkFenceImportFlagsKHR
VkFenceImportFlagsKHR -> Int
forall b.
Bits b -> (b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
countTrailingZeros :: VkFenceImportFlagsKHR -> Int
$ccountTrailingZeros :: VkFenceImportFlagsKHR -> Int
countLeadingZeros :: VkFenceImportFlagsKHR -> Int
$ccountLeadingZeros :: VkFenceImportFlagsKHR -> Int
finiteBitSize :: VkFenceImportFlagsKHR -> Int
$cfiniteBitSize :: VkFenceImportFlagsKHR -> Int
FiniteBits, Ptr VkFenceImportFlagsKHR -> IO VkFenceImportFlagsKHR
Ptr VkFenceImportFlagsKHR -> Int -> IO VkFenceImportFlagsKHR
Ptr VkFenceImportFlagsKHR -> Int -> VkFenceImportFlagsKHR -> IO ()
Ptr VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR -> IO ()
VkFenceImportFlagsKHR -> Int
(VkFenceImportFlagsKHR -> Int)
-> (VkFenceImportFlagsKHR -> Int)
-> (Ptr VkFenceImportFlagsKHR -> Int -> IO VkFenceImportFlagsKHR)
-> (Ptr VkFenceImportFlagsKHR
    -> Int -> VkFenceImportFlagsKHR -> IO ())
-> (forall b. Ptr b -> Int -> IO VkFenceImportFlagsKHR)
-> (forall b. Ptr b -> Int -> VkFenceImportFlagsKHR -> IO ())
-> (Ptr VkFenceImportFlagsKHR -> IO VkFenceImportFlagsKHR)
-> (Ptr VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR -> IO ())
-> Storable VkFenceImportFlagsKHR
forall b. Ptr b -> Int -> IO VkFenceImportFlagsKHR
forall b. Ptr b -> Int -> VkFenceImportFlagsKHR -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR -> IO ()
$cpoke :: Ptr VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR -> IO ()
peek :: Ptr VkFenceImportFlagsKHR -> IO VkFenceImportFlagsKHR
$cpeek :: Ptr VkFenceImportFlagsKHR -> IO VkFenceImportFlagsKHR
pokeByteOff :: forall b. Ptr b -> Int -> VkFenceImportFlagsKHR -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> VkFenceImportFlagsKHR -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO VkFenceImportFlagsKHR
$cpeekByteOff :: forall b. Ptr b -> Int -> IO VkFenceImportFlagsKHR
pokeElemOff :: Ptr VkFenceImportFlagsKHR -> Int -> VkFenceImportFlagsKHR -> IO ()
$cpokeElemOff :: Ptr VkFenceImportFlagsKHR -> Int -> VkFenceImportFlagsKHR -> IO ()
peekElemOff :: Ptr VkFenceImportFlagsKHR -> Int -> IO VkFenceImportFlagsKHR
$cpeekElemOff :: Ptr VkFenceImportFlagsKHR -> Int -> IO VkFenceImportFlagsKHR
alignment :: VkFenceImportFlagsKHR -> Int
$calignment :: VkFenceImportFlagsKHR -> Int
sizeOf :: VkFenceImportFlagsKHR -> Int
$csizeOf :: VkFenceImportFlagsKHR -> Int
Storable)

instance Show VkFenceImportFlagsKHR where
    {-# INLINE showsPrec #-}
    showsPrec :: Int -> VkFenceImportFlagsKHR -> ShowS
showsPrec = (Int -> VkFlags -> ShowS) -> Int -> VkFenceImportFlagsKHR -> ShowS
coerce (Int -> VkFlags -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec :: Int -> VkFlags -> ShowS)

instance Read VkFenceImportFlagsKHR where
    {-# INLINE readsPrec #-}
    readsPrec :: Int -> ReadS VkFenceImportFlagsKHR
readsPrec = (Int -> ReadS VkFlags) -> Int -> ReadS VkFenceImportFlagsKHR
coerce (Int -> ReadS VkFlags
forall a. Read a => Int -> ReadS a
readsPrec :: Int -> ReadS VkFlags)

newtype VkGeometryFlagsNV = VkGeometryFlagsNV VkFlags
                            deriving (VkGeometryFlagsNV -> VkGeometryFlagsNV -> Bool
(VkGeometryFlagsNV -> VkGeometryFlagsNV -> Bool)
-> (VkGeometryFlagsNV -> VkGeometryFlagsNV -> Bool)
-> Eq VkGeometryFlagsNV
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VkGeometryFlagsNV -> VkGeometryFlagsNV -> Bool
$c/= :: VkGeometryFlagsNV -> VkGeometryFlagsNV -> Bool
== :: VkGeometryFlagsNV -> VkGeometryFlagsNV -> Bool
$c== :: VkGeometryFlagsNV -> VkGeometryFlagsNV -> Bool
Eq, Eq VkGeometryFlagsNV
Eq VkGeometryFlagsNV
-> (VkGeometryFlagsNV -> VkGeometryFlagsNV -> Ordering)
-> (VkGeometryFlagsNV -> VkGeometryFlagsNV -> Bool)
-> (VkGeometryFlagsNV -> VkGeometryFlagsNV -> Bool)
-> (VkGeometryFlagsNV -> VkGeometryFlagsNV -> Bool)
-> (VkGeometryFlagsNV -> VkGeometryFlagsNV -> Bool)
-> (VkGeometryFlagsNV -> VkGeometryFlagsNV -> VkGeometryFlagsNV)
-> (VkGeometryFlagsNV -> VkGeometryFlagsNV -> VkGeometryFlagsNV)
-> Ord VkGeometryFlagsNV
VkGeometryFlagsNV -> VkGeometryFlagsNV -> Bool
VkGeometryFlagsNV -> VkGeometryFlagsNV -> Ordering
VkGeometryFlagsNV -> VkGeometryFlagsNV -> VkGeometryFlagsNV
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: VkGeometryFlagsNV -> VkGeometryFlagsNV -> VkGeometryFlagsNV
$cmin :: VkGeometryFlagsNV -> VkGeometryFlagsNV -> VkGeometryFlagsNV
max :: VkGeometryFlagsNV -> VkGeometryFlagsNV -> VkGeometryFlagsNV
$cmax :: VkGeometryFlagsNV -> VkGeometryFlagsNV -> VkGeometryFlagsNV
>= :: VkGeometryFlagsNV -> VkGeometryFlagsNV -> Bool
$c>= :: VkGeometryFlagsNV -> VkGeometryFlagsNV -> Bool
> :: VkGeometryFlagsNV -> VkGeometryFlagsNV -> Bool
$c> :: VkGeometryFlagsNV -> VkGeometryFlagsNV -> Bool
<= :: VkGeometryFlagsNV -> VkGeometryFlagsNV -> Bool
$c<= :: VkGeometryFlagsNV -> VkGeometryFlagsNV -> Bool
< :: VkGeometryFlagsNV -> VkGeometryFlagsNV -> Bool
$c< :: VkGeometryFlagsNV -> VkGeometryFlagsNV -> Bool
compare :: VkGeometryFlagsNV -> VkGeometryFlagsNV -> Ordering
$ccompare :: VkGeometryFlagsNV -> VkGeometryFlagsNV -> Ordering
Ord, Int -> VkGeometryFlagsNV
VkGeometryFlagsNV -> Int
VkGeometryFlagsNV -> [VkGeometryFlagsNV]
VkGeometryFlagsNV -> VkGeometryFlagsNV
VkGeometryFlagsNV -> VkGeometryFlagsNV -> [VkGeometryFlagsNV]
VkGeometryFlagsNV
-> VkGeometryFlagsNV -> VkGeometryFlagsNV -> [VkGeometryFlagsNV]
(VkGeometryFlagsNV -> VkGeometryFlagsNV)
-> (VkGeometryFlagsNV -> VkGeometryFlagsNV)
-> (Int -> VkGeometryFlagsNV)
-> (VkGeometryFlagsNV -> Int)
-> (VkGeometryFlagsNV -> [VkGeometryFlagsNV])
-> (VkGeometryFlagsNV -> VkGeometryFlagsNV -> [VkGeometryFlagsNV])
-> (VkGeometryFlagsNV -> VkGeometryFlagsNV -> [VkGeometryFlagsNV])
-> (VkGeometryFlagsNV
    -> VkGeometryFlagsNV -> VkGeometryFlagsNV -> [VkGeometryFlagsNV])
-> Enum VkGeometryFlagsNV
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: VkGeometryFlagsNV
-> VkGeometryFlagsNV -> VkGeometryFlagsNV -> [VkGeometryFlagsNV]
$cenumFromThenTo :: VkGeometryFlagsNV
-> VkGeometryFlagsNV -> VkGeometryFlagsNV -> [VkGeometryFlagsNV]
enumFromTo :: VkGeometryFlagsNV -> VkGeometryFlagsNV -> [VkGeometryFlagsNV]
$cenumFromTo :: VkGeometryFlagsNV -> VkGeometryFlagsNV -> [VkGeometryFlagsNV]
enumFromThen :: VkGeometryFlagsNV -> VkGeometryFlagsNV -> [VkGeometryFlagsNV]
$cenumFromThen :: VkGeometryFlagsNV -> VkGeometryFlagsNV -> [VkGeometryFlagsNV]
enumFrom :: VkGeometryFlagsNV -> [VkGeometryFlagsNV]
$cenumFrom :: VkGeometryFlagsNV -> [VkGeometryFlagsNV]
fromEnum :: VkGeometryFlagsNV -> Int
$cfromEnum :: VkGeometryFlagsNV -> Int
toEnum :: Int -> VkGeometryFlagsNV
$ctoEnum :: Int -> VkGeometryFlagsNV
pred :: VkGeometryFlagsNV -> VkGeometryFlagsNV
$cpred :: VkGeometryFlagsNV -> VkGeometryFlagsNV
succ :: VkGeometryFlagsNV -> VkGeometryFlagsNV
$csucc :: VkGeometryFlagsNV -> VkGeometryFlagsNV
Enum, Eq VkGeometryFlagsNV
VkGeometryFlagsNV
Eq VkGeometryFlagsNV
-> (VkGeometryFlagsNV -> VkGeometryFlagsNV -> VkGeometryFlagsNV)
-> (VkGeometryFlagsNV -> VkGeometryFlagsNV -> VkGeometryFlagsNV)
-> (VkGeometryFlagsNV -> VkGeometryFlagsNV -> VkGeometryFlagsNV)
-> (VkGeometryFlagsNV -> VkGeometryFlagsNV)
-> (VkGeometryFlagsNV -> Int -> VkGeometryFlagsNV)
-> (VkGeometryFlagsNV -> Int -> VkGeometryFlagsNV)
-> VkGeometryFlagsNV
-> (Int -> VkGeometryFlagsNV)
-> (VkGeometryFlagsNV -> Int -> VkGeometryFlagsNV)
-> (VkGeometryFlagsNV -> Int -> VkGeometryFlagsNV)
-> (VkGeometryFlagsNV -> Int -> VkGeometryFlagsNV)
-> (VkGeometryFlagsNV -> Int -> Bool)
-> (VkGeometryFlagsNV -> Maybe Int)
-> (VkGeometryFlagsNV -> Int)
-> (VkGeometryFlagsNV -> Bool)
-> (VkGeometryFlagsNV -> Int -> VkGeometryFlagsNV)
-> (VkGeometryFlagsNV -> Int -> VkGeometryFlagsNV)
-> (VkGeometryFlagsNV -> Int -> VkGeometryFlagsNV)
-> (VkGeometryFlagsNV -> Int -> VkGeometryFlagsNV)
-> (VkGeometryFlagsNV -> Int -> VkGeometryFlagsNV)
-> (VkGeometryFlagsNV -> Int -> VkGeometryFlagsNV)
-> (VkGeometryFlagsNV -> Int)
-> Bits VkGeometryFlagsNV
Int -> VkGeometryFlagsNV
VkGeometryFlagsNV -> Bool
VkGeometryFlagsNV -> Int
VkGeometryFlagsNV -> Maybe Int
VkGeometryFlagsNV -> VkGeometryFlagsNV
VkGeometryFlagsNV -> Int -> Bool
VkGeometryFlagsNV -> Int -> VkGeometryFlagsNV
VkGeometryFlagsNV -> VkGeometryFlagsNV -> VkGeometryFlagsNV
forall a.
Eq a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
popCount :: VkGeometryFlagsNV -> Int
$cpopCount :: VkGeometryFlagsNV -> Int
rotateR :: VkGeometryFlagsNV -> Int -> VkGeometryFlagsNV
$crotateR :: VkGeometryFlagsNV -> Int -> VkGeometryFlagsNV
rotateL :: VkGeometryFlagsNV -> Int -> VkGeometryFlagsNV
$crotateL :: VkGeometryFlagsNV -> Int -> VkGeometryFlagsNV
unsafeShiftR :: VkGeometryFlagsNV -> Int -> VkGeometryFlagsNV
$cunsafeShiftR :: VkGeometryFlagsNV -> Int -> VkGeometryFlagsNV
shiftR :: VkGeometryFlagsNV -> Int -> VkGeometryFlagsNV
$cshiftR :: VkGeometryFlagsNV -> Int -> VkGeometryFlagsNV
unsafeShiftL :: VkGeometryFlagsNV -> Int -> VkGeometryFlagsNV
$cunsafeShiftL :: VkGeometryFlagsNV -> Int -> VkGeometryFlagsNV
shiftL :: VkGeometryFlagsNV -> Int -> VkGeometryFlagsNV
$cshiftL :: VkGeometryFlagsNV -> Int -> VkGeometryFlagsNV
isSigned :: VkGeometryFlagsNV -> Bool
$cisSigned :: VkGeometryFlagsNV -> Bool
bitSize :: VkGeometryFlagsNV -> Int
$cbitSize :: VkGeometryFlagsNV -> Int
bitSizeMaybe :: VkGeometryFlagsNV -> Maybe Int
$cbitSizeMaybe :: VkGeometryFlagsNV -> Maybe Int
testBit :: VkGeometryFlagsNV -> Int -> Bool
$ctestBit :: VkGeometryFlagsNV -> Int -> Bool
complementBit :: VkGeometryFlagsNV -> Int -> VkGeometryFlagsNV
$ccomplementBit :: VkGeometryFlagsNV -> Int -> VkGeometryFlagsNV
clearBit :: VkGeometryFlagsNV -> Int -> VkGeometryFlagsNV
$cclearBit :: VkGeometryFlagsNV -> Int -> VkGeometryFlagsNV
setBit :: VkGeometryFlagsNV -> Int -> VkGeometryFlagsNV
$csetBit :: VkGeometryFlagsNV -> Int -> VkGeometryFlagsNV
bit :: Int -> VkGeometryFlagsNV
$cbit :: Int -> VkGeometryFlagsNV
zeroBits :: VkGeometryFlagsNV
$czeroBits :: VkGeometryFlagsNV
rotate :: VkGeometryFlagsNV -> Int -> VkGeometryFlagsNV
$crotate :: VkGeometryFlagsNV -> Int -> VkGeometryFlagsNV
shift :: VkGeometryFlagsNV -> Int -> VkGeometryFlagsNV
$cshift :: VkGeometryFlagsNV -> Int -> VkGeometryFlagsNV
complement :: VkGeometryFlagsNV -> VkGeometryFlagsNV
$ccomplement :: VkGeometryFlagsNV -> VkGeometryFlagsNV
xor :: VkGeometryFlagsNV -> VkGeometryFlagsNV -> VkGeometryFlagsNV
$cxor :: VkGeometryFlagsNV -> VkGeometryFlagsNV -> VkGeometryFlagsNV
.|. :: VkGeometryFlagsNV -> VkGeometryFlagsNV -> VkGeometryFlagsNV
$c.|. :: VkGeometryFlagsNV -> VkGeometryFlagsNV -> VkGeometryFlagsNV
.&. :: VkGeometryFlagsNV -> VkGeometryFlagsNV -> VkGeometryFlagsNV
$c.&. :: VkGeometryFlagsNV -> VkGeometryFlagsNV -> VkGeometryFlagsNV
Bits, Bits VkGeometryFlagsNV
Bits VkGeometryFlagsNV
-> (VkGeometryFlagsNV -> Int)
-> (VkGeometryFlagsNV -> Int)
-> (VkGeometryFlagsNV -> Int)
-> FiniteBits VkGeometryFlagsNV
VkGeometryFlagsNV -> Int
forall b.
Bits b -> (b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
countTrailingZeros :: VkGeometryFlagsNV -> Int
$ccountTrailingZeros :: VkGeometryFlagsNV -> Int
countLeadingZeros :: VkGeometryFlagsNV -> Int
$ccountLeadingZeros :: VkGeometryFlagsNV -> Int
finiteBitSize :: VkGeometryFlagsNV -> Int
$cfiniteBitSize :: VkGeometryFlagsNV -> Int
FiniteBits, Ptr VkGeometryFlagsNV -> IO VkGeometryFlagsNV
Ptr VkGeometryFlagsNV -> Int -> IO VkGeometryFlagsNV
Ptr VkGeometryFlagsNV -> Int -> VkGeometryFlagsNV -> IO ()
Ptr VkGeometryFlagsNV -> VkGeometryFlagsNV -> IO ()
VkGeometryFlagsNV -> Int
(VkGeometryFlagsNV -> Int)
-> (VkGeometryFlagsNV -> Int)
-> (Ptr VkGeometryFlagsNV -> Int -> IO VkGeometryFlagsNV)
-> (Ptr VkGeometryFlagsNV -> Int -> VkGeometryFlagsNV -> IO ())
-> (forall b. Ptr b -> Int -> IO VkGeometryFlagsNV)
-> (forall b. Ptr b -> Int -> VkGeometryFlagsNV -> IO ())
-> (Ptr VkGeometryFlagsNV -> IO VkGeometryFlagsNV)
-> (Ptr VkGeometryFlagsNV -> VkGeometryFlagsNV -> IO ())
-> Storable VkGeometryFlagsNV
forall b. Ptr b -> Int -> IO VkGeometryFlagsNV
forall b. Ptr b -> Int -> VkGeometryFlagsNV -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr VkGeometryFlagsNV -> VkGeometryFlagsNV -> IO ()
$cpoke :: Ptr VkGeometryFlagsNV -> VkGeometryFlagsNV -> IO ()
peek :: Ptr VkGeometryFlagsNV -> IO VkGeometryFlagsNV
$cpeek :: Ptr VkGeometryFlagsNV -> IO VkGeometryFlagsNV
pokeByteOff :: forall b. Ptr b -> Int -> VkGeometryFlagsNV -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> VkGeometryFlagsNV -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO VkGeometryFlagsNV
$cpeekByteOff :: forall b. Ptr b -> Int -> IO VkGeometryFlagsNV
pokeElemOff :: Ptr VkGeometryFlagsNV -> Int -> VkGeometryFlagsNV -> IO ()
$cpokeElemOff :: Ptr VkGeometryFlagsNV -> Int -> VkGeometryFlagsNV -> IO ()
peekElemOff :: Ptr VkGeometryFlagsNV -> Int -> IO VkGeometryFlagsNV
$cpeekElemOff :: Ptr VkGeometryFlagsNV -> Int -> IO VkGeometryFlagsNV
alignment :: VkGeometryFlagsNV -> Int
$calignment :: VkGeometryFlagsNV -> Int
sizeOf :: VkGeometryFlagsNV -> Int
$csizeOf :: VkGeometryFlagsNV -> Int
Storable)

instance Show VkGeometryFlagsNV where
    {-# INLINE showsPrec #-}
    showsPrec :: Int -> VkGeometryFlagsNV -> ShowS
showsPrec = (Int -> VkFlags -> ShowS) -> Int -> VkGeometryFlagsNV -> ShowS
coerce (Int -> VkFlags -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec :: Int -> VkFlags -> ShowS)

instance Read VkGeometryFlagsNV where
    {-# INLINE readsPrec #-}
    readsPrec :: Int -> ReadS VkGeometryFlagsNV
readsPrec = (Int -> ReadS VkFlags) -> Int -> ReadS VkGeometryFlagsNV
coerce (Int -> ReadS VkFlags
forall a. Read a => Int -> ReadS a
readsPrec :: Int -> ReadS VkFlags)

newtype VkGeometryInstanceFlagsNV = VkGeometryInstanceFlagsNV VkFlags
                                    deriving (VkGeometryInstanceFlagsNV -> VkGeometryInstanceFlagsNV -> Bool
(VkGeometryInstanceFlagsNV -> VkGeometryInstanceFlagsNV -> Bool)
-> (VkGeometryInstanceFlagsNV -> VkGeometryInstanceFlagsNV -> Bool)
-> Eq VkGeometryInstanceFlagsNV
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VkGeometryInstanceFlagsNV -> VkGeometryInstanceFlagsNV -> Bool
$c/= :: VkGeometryInstanceFlagsNV -> VkGeometryInstanceFlagsNV -> Bool
== :: VkGeometryInstanceFlagsNV -> VkGeometryInstanceFlagsNV -> Bool
$c== :: VkGeometryInstanceFlagsNV -> VkGeometryInstanceFlagsNV -> Bool
Eq, Eq VkGeometryInstanceFlagsNV
Eq VkGeometryInstanceFlagsNV
-> (VkGeometryInstanceFlagsNV
    -> VkGeometryInstanceFlagsNV -> Ordering)
-> (VkGeometryInstanceFlagsNV -> VkGeometryInstanceFlagsNV -> Bool)
-> (VkGeometryInstanceFlagsNV -> VkGeometryInstanceFlagsNV -> Bool)
-> (VkGeometryInstanceFlagsNV -> VkGeometryInstanceFlagsNV -> Bool)
-> (VkGeometryInstanceFlagsNV -> VkGeometryInstanceFlagsNV -> Bool)
-> (VkGeometryInstanceFlagsNV
    -> VkGeometryInstanceFlagsNV -> VkGeometryInstanceFlagsNV)
-> (VkGeometryInstanceFlagsNV
    -> VkGeometryInstanceFlagsNV -> VkGeometryInstanceFlagsNV)
-> Ord VkGeometryInstanceFlagsNV
VkGeometryInstanceFlagsNV -> VkGeometryInstanceFlagsNV -> Bool
VkGeometryInstanceFlagsNV -> VkGeometryInstanceFlagsNV -> Ordering
VkGeometryInstanceFlagsNV
-> VkGeometryInstanceFlagsNV -> VkGeometryInstanceFlagsNV
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: VkGeometryInstanceFlagsNV
-> VkGeometryInstanceFlagsNV -> VkGeometryInstanceFlagsNV
$cmin :: VkGeometryInstanceFlagsNV
-> VkGeometryInstanceFlagsNV -> VkGeometryInstanceFlagsNV
max :: VkGeometryInstanceFlagsNV
-> VkGeometryInstanceFlagsNV -> VkGeometryInstanceFlagsNV
$cmax :: VkGeometryInstanceFlagsNV
-> VkGeometryInstanceFlagsNV -> VkGeometryInstanceFlagsNV
>= :: VkGeometryInstanceFlagsNV -> VkGeometryInstanceFlagsNV -> Bool
$c>= :: VkGeometryInstanceFlagsNV -> VkGeometryInstanceFlagsNV -> Bool
> :: VkGeometryInstanceFlagsNV -> VkGeometryInstanceFlagsNV -> Bool
$c> :: VkGeometryInstanceFlagsNV -> VkGeometryInstanceFlagsNV -> Bool
<= :: VkGeometryInstanceFlagsNV -> VkGeometryInstanceFlagsNV -> Bool
$c<= :: VkGeometryInstanceFlagsNV -> VkGeometryInstanceFlagsNV -> Bool
< :: VkGeometryInstanceFlagsNV -> VkGeometryInstanceFlagsNV -> Bool
$c< :: VkGeometryInstanceFlagsNV -> VkGeometryInstanceFlagsNV -> Bool
compare :: VkGeometryInstanceFlagsNV -> VkGeometryInstanceFlagsNV -> Ordering
$ccompare :: VkGeometryInstanceFlagsNV -> VkGeometryInstanceFlagsNV -> Ordering
Ord, Int -> VkGeometryInstanceFlagsNV
VkGeometryInstanceFlagsNV -> Int
VkGeometryInstanceFlagsNV -> [VkGeometryInstanceFlagsNV]
VkGeometryInstanceFlagsNV -> VkGeometryInstanceFlagsNV
VkGeometryInstanceFlagsNV
-> VkGeometryInstanceFlagsNV -> [VkGeometryInstanceFlagsNV]
VkGeometryInstanceFlagsNV
-> VkGeometryInstanceFlagsNV
-> VkGeometryInstanceFlagsNV
-> [VkGeometryInstanceFlagsNV]
(VkGeometryInstanceFlagsNV -> VkGeometryInstanceFlagsNV)
-> (VkGeometryInstanceFlagsNV -> VkGeometryInstanceFlagsNV)
-> (Int -> VkGeometryInstanceFlagsNV)
-> (VkGeometryInstanceFlagsNV -> Int)
-> (VkGeometryInstanceFlagsNV -> [VkGeometryInstanceFlagsNV])
-> (VkGeometryInstanceFlagsNV
    -> VkGeometryInstanceFlagsNV -> [VkGeometryInstanceFlagsNV])
-> (VkGeometryInstanceFlagsNV
    -> VkGeometryInstanceFlagsNV -> [VkGeometryInstanceFlagsNV])
-> (VkGeometryInstanceFlagsNV
    -> VkGeometryInstanceFlagsNV
    -> VkGeometryInstanceFlagsNV
    -> [VkGeometryInstanceFlagsNV])
-> Enum VkGeometryInstanceFlagsNV
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: VkGeometryInstanceFlagsNV
-> VkGeometryInstanceFlagsNV
-> VkGeometryInstanceFlagsNV
-> [VkGeometryInstanceFlagsNV]
$cenumFromThenTo :: VkGeometryInstanceFlagsNV
-> VkGeometryInstanceFlagsNV
-> VkGeometryInstanceFlagsNV
-> [VkGeometryInstanceFlagsNV]
enumFromTo :: VkGeometryInstanceFlagsNV
-> VkGeometryInstanceFlagsNV -> [VkGeometryInstanceFlagsNV]
$cenumFromTo :: VkGeometryInstanceFlagsNV
-> VkGeometryInstanceFlagsNV -> [VkGeometryInstanceFlagsNV]
enumFromThen :: VkGeometryInstanceFlagsNV
-> VkGeometryInstanceFlagsNV -> [VkGeometryInstanceFlagsNV]
$cenumFromThen :: VkGeometryInstanceFlagsNV
-> VkGeometryInstanceFlagsNV -> [VkGeometryInstanceFlagsNV]
enumFrom :: VkGeometryInstanceFlagsNV -> [VkGeometryInstanceFlagsNV]
$cenumFrom :: VkGeometryInstanceFlagsNV -> [VkGeometryInstanceFlagsNV]
fromEnum :: VkGeometryInstanceFlagsNV -> Int
$cfromEnum :: VkGeometryInstanceFlagsNV -> Int
toEnum :: Int -> VkGeometryInstanceFlagsNV
$ctoEnum :: Int -> VkGeometryInstanceFlagsNV
pred :: VkGeometryInstanceFlagsNV -> VkGeometryInstanceFlagsNV
$cpred :: VkGeometryInstanceFlagsNV -> VkGeometryInstanceFlagsNV
succ :: VkGeometryInstanceFlagsNV -> VkGeometryInstanceFlagsNV
$csucc :: VkGeometryInstanceFlagsNV -> VkGeometryInstanceFlagsNV
Enum, Eq VkGeometryInstanceFlagsNV
VkGeometryInstanceFlagsNV
Eq VkGeometryInstanceFlagsNV
-> (VkGeometryInstanceFlagsNV
    -> VkGeometryInstanceFlagsNV -> VkGeometryInstanceFlagsNV)
-> (VkGeometryInstanceFlagsNV
    -> VkGeometryInstanceFlagsNV -> VkGeometryInstanceFlagsNV)
-> (VkGeometryInstanceFlagsNV
    -> VkGeometryInstanceFlagsNV -> VkGeometryInstanceFlagsNV)
-> (VkGeometryInstanceFlagsNV -> VkGeometryInstanceFlagsNV)
-> (VkGeometryInstanceFlagsNV -> Int -> VkGeometryInstanceFlagsNV)
-> (VkGeometryInstanceFlagsNV -> Int -> VkGeometryInstanceFlagsNV)
-> VkGeometryInstanceFlagsNV
-> (Int -> VkGeometryInstanceFlagsNV)
-> (VkGeometryInstanceFlagsNV -> Int -> VkGeometryInstanceFlagsNV)
-> (VkGeometryInstanceFlagsNV -> Int -> VkGeometryInstanceFlagsNV)
-> (VkGeometryInstanceFlagsNV -> Int -> VkGeometryInstanceFlagsNV)
-> (VkGeometryInstanceFlagsNV -> Int -> Bool)
-> (VkGeometryInstanceFlagsNV -> Maybe Int)
-> (VkGeometryInstanceFlagsNV -> Int)
-> (VkGeometryInstanceFlagsNV -> Bool)
-> (VkGeometryInstanceFlagsNV -> Int -> VkGeometryInstanceFlagsNV)
-> (VkGeometryInstanceFlagsNV -> Int -> VkGeometryInstanceFlagsNV)
-> (VkGeometryInstanceFlagsNV -> Int -> VkGeometryInstanceFlagsNV)
-> (VkGeometryInstanceFlagsNV -> Int -> VkGeometryInstanceFlagsNV)
-> (VkGeometryInstanceFlagsNV -> Int -> VkGeometryInstanceFlagsNV)
-> (VkGeometryInstanceFlagsNV -> Int -> VkGeometryInstanceFlagsNV)
-> (VkGeometryInstanceFlagsNV -> Int)
-> Bits VkGeometryInstanceFlagsNV
Int -> VkGeometryInstanceFlagsNV
VkGeometryInstanceFlagsNV -> Bool
VkGeometryInstanceFlagsNV -> Int
VkGeometryInstanceFlagsNV -> Maybe Int
VkGeometryInstanceFlagsNV -> VkGeometryInstanceFlagsNV
VkGeometryInstanceFlagsNV -> Int -> Bool
VkGeometryInstanceFlagsNV -> Int -> VkGeometryInstanceFlagsNV
VkGeometryInstanceFlagsNV
-> VkGeometryInstanceFlagsNV -> VkGeometryInstanceFlagsNV
forall a.
Eq a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
popCount :: VkGeometryInstanceFlagsNV -> Int
$cpopCount :: VkGeometryInstanceFlagsNV -> Int
rotateR :: VkGeometryInstanceFlagsNV -> Int -> VkGeometryInstanceFlagsNV
$crotateR :: VkGeometryInstanceFlagsNV -> Int -> VkGeometryInstanceFlagsNV
rotateL :: VkGeometryInstanceFlagsNV -> Int -> VkGeometryInstanceFlagsNV
$crotateL :: VkGeometryInstanceFlagsNV -> Int -> VkGeometryInstanceFlagsNV
unsafeShiftR :: VkGeometryInstanceFlagsNV -> Int -> VkGeometryInstanceFlagsNV
$cunsafeShiftR :: VkGeometryInstanceFlagsNV -> Int -> VkGeometryInstanceFlagsNV
shiftR :: VkGeometryInstanceFlagsNV -> Int -> VkGeometryInstanceFlagsNV
$cshiftR :: VkGeometryInstanceFlagsNV -> Int -> VkGeometryInstanceFlagsNV
unsafeShiftL :: VkGeometryInstanceFlagsNV -> Int -> VkGeometryInstanceFlagsNV
$cunsafeShiftL :: VkGeometryInstanceFlagsNV -> Int -> VkGeometryInstanceFlagsNV
shiftL :: VkGeometryInstanceFlagsNV -> Int -> VkGeometryInstanceFlagsNV
$cshiftL :: VkGeometryInstanceFlagsNV -> Int -> VkGeometryInstanceFlagsNV
isSigned :: VkGeometryInstanceFlagsNV -> Bool
$cisSigned :: VkGeometryInstanceFlagsNV -> Bool
bitSize :: VkGeometryInstanceFlagsNV -> Int
$cbitSize :: VkGeometryInstanceFlagsNV -> Int
bitSizeMaybe :: VkGeometryInstanceFlagsNV -> Maybe Int
$cbitSizeMaybe :: VkGeometryInstanceFlagsNV -> Maybe Int
testBit :: VkGeometryInstanceFlagsNV -> Int -> Bool
$ctestBit :: VkGeometryInstanceFlagsNV -> Int -> Bool
complementBit :: VkGeometryInstanceFlagsNV -> Int -> VkGeometryInstanceFlagsNV
$ccomplementBit :: VkGeometryInstanceFlagsNV -> Int -> VkGeometryInstanceFlagsNV
clearBit :: VkGeometryInstanceFlagsNV -> Int -> VkGeometryInstanceFlagsNV
$cclearBit :: VkGeometryInstanceFlagsNV -> Int -> VkGeometryInstanceFlagsNV
setBit :: VkGeometryInstanceFlagsNV -> Int -> VkGeometryInstanceFlagsNV
$csetBit :: VkGeometryInstanceFlagsNV -> Int -> VkGeometryInstanceFlagsNV
bit :: Int -> VkGeometryInstanceFlagsNV
$cbit :: Int -> VkGeometryInstanceFlagsNV
zeroBits :: VkGeometryInstanceFlagsNV
$czeroBits :: VkGeometryInstanceFlagsNV
rotate :: VkGeometryInstanceFlagsNV -> Int -> VkGeometryInstanceFlagsNV
$crotate :: VkGeometryInstanceFlagsNV -> Int -> VkGeometryInstanceFlagsNV
shift :: VkGeometryInstanceFlagsNV -> Int -> VkGeometryInstanceFlagsNV
$cshift :: VkGeometryInstanceFlagsNV -> Int -> VkGeometryInstanceFlagsNV
complement :: VkGeometryInstanceFlagsNV -> VkGeometryInstanceFlagsNV
$ccomplement :: VkGeometryInstanceFlagsNV -> VkGeometryInstanceFlagsNV
xor :: VkGeometryInstanceFlagsNV
-> VkGeometryInstanceFlagsNV -> VkGeometryInstanceFlagsNV
$cxor :: VkGeometryInstanceFlagsNV
-> VkGeometryInstanceFlagsNV -> VkGeometryInstanceFlagsNV
.|. :: VkGeometryInstanceFlagsNV
-> VkGeometryInstanceFlagsNV -> VkGeometryInstanceFlagsNV
$c.|. :: VkGeometryInstanceFlagsNV
-> VkGeometryInstanceFlagsNV -> VkGeometryInstanceFlagsNV
.&. :: VkGeometryInstanceFlagsNV
-> VkGeometryInstanceFlagsNV -> VkGeometryInstanceFlagsNV
$c.&. :: VkGeometryInstanceFlagsNV
-> VkGeometryInstanceFlagsNV -> VkGeometryInstanceFlagsNV
Bits, Bits VkGeometryInstanceFlagsNV
Bits VkGeometryInstanceFlagsNV
-> (VkGeometryInstanceFlagsNV -> Int)
-> (VkGeometryInstanceFlagsNV -> Int)
-> (VkGeometryInstanceFlagsNV -> Int)
-> FiniteBits VkGeometryInstanceFlagsNV
VkGeometryInstanceFlagsNV -> Int
forall b.
Bits b -> (b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
countTrailingZeros :: VkGeometryInstanceFlagsNV -> Int
$ccountTrailingZeros :: VkGeometryInstanceFlagsNV -> Int
countLeadingZeros :: VkGeometryInstanceFlagsNV -> Int
$ccountLeadingZeros :: VkGeometryInstanceFlagsNV -> Int
finiteBitSize :: VkGeometryInstanceFlagsNV -> Int
$cfiniteBitSize :: VkGeometryInstanceFlagsNV -> Int
FiniteBits, Ptr VkGeometryInstanceFlagsNV -> IO VkGeometryInstanceFlagsNV
Ptr VkGeometryInstanceFlagsNV
-> Int -> IO VkGeometryInstanceFlagsNV
Ptr VkGeometryInstanceFlagsNV
-> Int -> VkGeometryInstanceFlagsNV -> IO ()
Ptr VkGeometryInstanceFlagsNV -> VkGeometryInstanceFlagsNV -> IO ()
VkGeometryInstanceFlagsNV -> Int
(VkGeometryInstanceFlagsNV -> Int)
-> (VkGeometryInstanceFlagsNV -> Int)
-> (Ptr VkGeometryInstanceFlagsNV
    -> Int -> IO VkGeometryInstanceFlagsNV)
-> (Ptr VkGeometryInstanceFlagsNV
    -> Int -> VkGeometryInstanceFlagsNV -> IO ())
-> (forall b. Ptr b -> Int -> IO VkGeometryInstanceFlagsNV)
-> (forall b. Ptr b -> Int -> VkGeometryInstanceFlagsNV -> IO ())
-> (Ptr VkGeometryInstanceFlagsNV -> IO VkGeometryInstanceFlagsNV)
-> (Ptr VkGeometryInstanceFlagsNV
    -> VkGeometryInstanceFlagsNV -> IO ())
-> Storable VkGeometryInstanceFlagsNV
forall b. Ptr b -> Int -> IO VkGeometryInstanceFlagsNV
forall b. Ptr b -> Int -> VkGeometryInstanceFlagsNV -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr VkGeometryInstanceFlagsNV -> VkGeometryInstanceFlagsNV -> IO ()
$cpoke :: Ptr VkGeometryInstanceFlagsNV -> VkGeometryInstanceFlagsNV -> IO ()
peek :: Ptr VkGeometryInstanceFlagsNV -> IO VkGeometryInstanceFlagsNV
$cpeek :: Ptr VkGeometryInstanceFlagsNV -> IO VkGeometryInstanceFlagsNV
pokeByteOff :: forall b. Ptr b -> Int -> VkGeometryInstanceFlagsNV -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> VkGeometryInstanceFlagsNV -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO VkGeometryInstanceFlagsNV
$cpeekByteOff :: forall b. Ptr b -> Int -> IO VkGeometryInstanceFlagsNV
pokeElemOff :: Ptr VkGeometryInstanceFlagsNV
-> Int -> VkGeometryInstanceFlagsNV -> IO ()
$cpokeElemOff :: Ptr VkGeometryInstanceFlagsNV
-> Int -> VkGeometryInstanceFlagsNV -> IO ()
peekElemOff :: Ptr VkGeometryInstanceFlagsNV
-> Int -> IO VkGeometryInstanceFlagsNV
$cpeekElemOff :: Ptr VkGeometryInstanceFlagsNV
-> Int -> IO VkGeometryInstanceFlagsNV
alignment :: VkGeometryInstanceFlagsNV -> Int
$calignment :: VkGeometryInstanceFlagsNV -> Int
sizeOf :: VkGeometryInstanceFlagsNV -> Int
$csizeOf :: VkGeometryInstanceFlagsNV -> Int
Storable)

instance Show VkGeometryInstanceFlagsNV where
    {-# INLINE showsPrec #-}
    showsPrec :: Int -> VkGeometryInstanceFlagsNV -> ShowS
showsPrec = (Int -> VkFlags -> ShowS)
-> Int -> VkGeometryInstanceFlagsNV -> ShowS
coerce (Int -> VkFlags -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec :: Int -> VkFlags -> ShowS)

instance Read VkGeometryInstanceFlagsNV where
    {-# INLINE readsPrec #-}
    readsPrec :: Int -> ReadS VkGeometryInstanceFlagsNV
readsPrec = (Int -> ReadS VkFlags) -> Int -> ReadS VkGeometryInstanceFlagsNV
coerce (Int -> ReadS VkFlags
forall a. Read a => Int -> ReadS a
readsPrec :: Int -> ReadS VkFlags)

newtype VkHeadlessSurfaceCreateFlagsEXT = VkHeadlessSurfaceCreateFlagsEXT VkFlags
                                          deriving (VkHeadlessSurfaceCreateFlagsEXT
-> VkHeadlessSurfaceCreateFlagsEXT -> Bool
(VkHeadlessSurfaceCreateFlagsEXT
 -> VkHeadlessSurfaceCreateFlagsEXT -> Bool)
-> (VkHeadlessSurfaceCreateFlagsEXT
    -> VkHeadlessSurfaceCreateFlagsEXT -> Bool)
-> Eq VkHeadlessSurfaceCreateFlagsEXT
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VkHeadlessSurfaceCreateFlagsEXT
-> VkHeadlessSurfaceCreateFlagsEXT -> Bool
$c/= :: VkHeadlessSurfaceCreateFlagsEXT
-> VkHeadlessSurfaceCreateFlagsEXT -> Bool
== :: VkHeadlessSurfaceCreateFlagsEXT
-> VkHeadlessSurfaceCreateFlagsEXT -> Bool
$c== :: VkHeadlessSurfaceCreateFlagsEXT
-> VkHeadlessSurfaceCreateFlagsEXT -> Bool
Eq, Eq VkHeadlessSurfaceCreateFlagsEXT
Eq VkHeadlessSurfaceCreateFlagsEXT
-> (VkHeadlessSurfaceCreateFlagsEXT
    -> VkHeadlessSurfaceCreateFlagsEXT -> Ordering)
-> (VkHeadlessSurfaceCreateFlagsEXT
    -> VkHeadlessSurfaceCreateFlagsEXT -> Bool)
-> (VkHeadlessSurfaceCreateFlagsEXT
    -> VkHeadlessSurfaceCreateFlagsEXT -> Bool)
-> (VkHeadlessSurfaceCreateFlagsEXT
    -> VkHeadlessSurfaceCreateFlagsEXT -> Bool)
-> (VkHeadlessSurfaceCreateFlagsEXT
    -> VkHeadlessSurfaceCreateFlagsEXT -> Bool)
-> (VkHeadlessSurfaceCreateFlagsEXT
    -> VkHeadlessSurfaceCreateFlagsEXT
    -> VkHeadlessSurfaceCreateFlagsEXT)
-> (VkHeadlessSurfaceCreateFlagsEXT
    -> VkHeadlessSurfaceCreateFlagsEXT
    -> VkHeadlessSurfaceCreateFlagsEXT)
-> Ord VkHeadlessSurfaceCreateFlagsEXT
VkHeadlessSurfaceCreateFlagsEXT
-> VkHeadlessSurfaceCreateFlagsEXT -> Bool
VkHeadlessSurfaceCreateFlagsEXT
-> VkHeadlessSurfaceCreateFlagsEXT -> Ordering
VkHeadlessSurfaceCreateFlagsEXT
-> VkHeadlessSurfaceCreateFlagsEXT
-> VkHeadlessSurfaceCreateFlagsEXT
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: VkHeadlessSurfaceCreateFlagsEXT
-> VkHeadlessSurfaceCreateFlagsEXT
-> VkHeadlessSurfaceCreateFlagsEXT
$cmin :: VkHeadlessSurfaceCreateFlagsEXT
-> VkHeadlessSurfaceCreateFlagsEXT
-> VkHeadlessSurfaceCreateFlagsEXT
max :: VkHeadlessSurfaceCreateFlagsEXT
-> VkHeadlessSurfaceCreateFlagsEXT
-> VkHeadlessSurfaceCreateFlagsEXT
$cmax :: VkHeadlessSurfaceCreateFlagsEXT
-> VkHeadlessSurfaceCreateFlagsEXT
-> VkHeadlessSurfaceCreateFlagsEXT
>= :: VkHeadlessSurfaceCreateFlagsEXT
-> VkHeadlessSurfaceCreateFlagsEXT -> Bool
$c>= :: VkHeadlessSurfaceCreateFlagsEXT
-> VkHeadlessSurfaceCreateFlagsEXT -> Bool
> :: VkHeadlessSurfaceCreateFlagsEXT
-> VkHeadlessSurfaceCreateFlagsEXT -> Bool
$c> :: VkHeadlessSurfaceCreateFlagsEXT
-> VkHeadlessSurfaceCreateFlagsEXT -> Bool
<= :: VkHeadlessSurfaceCreateFlagsEXT
-> VkHeadlessSurfaceCreateFlagsEXT -> Bool
$c<= :: VkHeadlessSurfaceCreateFlagsEXT
-> VkHeadlessSurfaceCreateFlagsEXT -> Bool
< :: VkHeadlessSurfaceCreateFlagsEXT
-> VkHeadlessSurfaceCreateFlagsEXT -> Bool
$c< :: VkHeadlessSurfaceCreateFlagsEXT
-> VkHeadlessSurfaceCreateFlagsEXT -> Bool
compare :: VkHeadlessSurfaceCreateFlagsEXT
-> VkHeadlessSurfaceCreateFlagsEXT -> Ordering
$ccompare :: VkHeadlessSurfaceCreateFlagsEXT
-> VkHeadlessSurfaceCreateFlagsEXT -> Ordering
Ord, Int -> VkHeadlessSurfaceCreateFlagsEXT
VkHeadlessSurfaceCreateFlagsEXT -> Int
VkHeadlessSurfaceCreateFlagsEXT
-> [VkHeadlessSurfaceCreateFlagsEXT]
VkHeadlessSurfaceCreateFlagsEXT -> VkHeadlessSurfaceCreateFlagsEXT
VkHeadlessSurfaceCreateFlagsEXT
-> VkHeadlessSurfaceCreateFlagsEXT
-> [VkHeadlessSurfaceCreateFlagsEXT]
VkHeadlessSurfaceCreateFlagsEXT
-> VkHeadlessSurfaceCreateFlagsEXT
-> VkHeadlessSurfaceCreateFlagsEXT
-> [VkHeadlessSurfaceCreateFlagsEXT]
(VkHeadlessSurfaceCreateFlagsEXT
 -> VkHeadlessSurfaceCreateFlagsEXT)
-> (VkHeadlessSurfaceCreateFlagsEXT
    -> VkHeadlessSurfaceCreateFlagsEXT)
-> (Int -> VkHeadlessSurfaceCreateFlagsEXT)
-> (VkHeadlessSurfaceCreateFlagsEXT -> Int)
-> (VkHeadlessSurfaceCreateFlagsEXT
    -> [VkHeadlessSurfaceCreateFlagsEXT])
-> (VkHeadlessSurfaceCreateFlagsEXT
    -> VkHeadlessSurfaceCreateFlagsEXT
    -> [VkHeadlessSurfaceCreateFlagsEXT])
-> (VkHeadlessSurfaceCreateFlagsEXT
    -> VkHeadlessSurfaceCreateFlagsEXT
    -> [VkHeadlessSurfaceCreateFlagsEXT])
-> (VkHeadlessSurfaceCreateFlagsEXT
    -> VkHeadlessSurfaceCreateFlagsEXT
    -> VkHeadlessSurfaceCreateFlagsEXT
    -> [VkHeadlessSurfaceCreateFlagsEXT])
-> Enum VkHeadlessSurfaceCreateFlagsEXT
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: VkHeadlessSurfaceCreateFlagsEXT
-> VkHeadlessSurfaceCreateFlagsEXT
-> VkHeadlessSurfaceCreateFlagsEXT
-> [VkHeadlessSurfaceCreateFlagsEXT]
$cenumFromThenTo :: VkHeadlessSurfaceCreateFlagsEXT
-> VkHeadlessSurfaceCreateFlagsEXT
-> VkHeadlessSurfaceCreateFlagsEXT
-> [VkHeadlessSurfaceCreateFlagsEXT]
enumFromTo :: VkHeadlessSurfaceCreateFlagsEXT
-> VkHeadlessSurfaceCreateFlagsEXT
-> [VkHeadlessSurfaceCreateFlagsEXT]
$cenumFromTo :: VkHeadlessSurfaceCreateFlagsEXT
-> VkHeadlessSurfaceCreateFlagsEXT
-> [VkHeadlessSurfaceCreateFlagsEXT]
enumFromThen :: VkHeadlessSurfaceCreateFlagsEXT
-> VkHeadlessSurfaceCreateFlagsEXT
-> [VkHeadlessSurfaceCreateFlagsEXT]
$cenumFromThen :: VkHeadlessSurfaceCreateFlagsEXT
-> VkHeadlessSurfaceCreateFlagsEXT
-> [VkHeadlessSurfaceCreateFlagsEXT]
enumFrom :: VkHeadlessSurfaceCreateFlagsEXT
-> [VkHeadlessSurfaceCreateFlagsEXT]
$cenumFrom :: VkHeadlessSurfaceCreateFlagsEXT
-> [VkHeadlessSurfaceCreateFlagsEXT]
fromEnum :: VkHeadlessSurfaceCreateFlagsEXT -> Int
$cfromEnum :: VkHeadlessSurfaceCreateFlagsEXT -> Int
toEnum :: Int -> VkHeadlessSurfaceCreateFlagsEXT
$ctoEnum :: Int -> VkHeadlessSurfaceCreateFlagsEXT
pred :: VkHeadlessSurfaceCreateFlagsEXT -> VkHeadlessSurfaceCreateFlagsEXT
$cpred :: VkHeadlessSurfaceCreateFlagsEXT -> VkHeadlessSurfaceCreateFlagsEXT
succ :: VkHeadlessSurfaceCreateFlagsEXT -> VkHeadlessSurfaceCreateFlagsEXT
$csucc :: VkHeadlessSurfaceCreateFlagsEXT -> VkHeadlessSurfaceCreateFlagsEXT
Enum, Eq VkHeadlessSurfaceCreateFlagsEXT
VkHeadlessSurfaceCreateFlagsEXT
Eq VkHeadlessSurfaceCreateFlagsEXT
-> (VkHeadlessSurfaceCreateFlagsEXT
    -> VkHeadlessSurfaceCreateFlagsEXT
    -> VkHeadlessSurfaceCreateFlagsEXT)
-> (VkHeadlessSurfaceCreateFlagsEXT
    -> VkHeadlessSurfaceCreateFlagsEXT
    -> VkHeadlessSurfaceCreateFlagsEXT)
-> (VkHeadlessSurfaceCreateFlagsEXT
    -> VkHeadlessSurfaceCreateFlagsEXT
    -> VkHeadlessSurfaceCreateFlagsEXT)
-> (VkHeadlessSurfaceCreateFlagsEXT
    -> VkHeadlessSurfaceCreateFlagsEXT)
-> (VkHeadlessSurfaceCreateFlagsEXT
    -> Int -> VkHeadlessSurfaceCreateFlagsEXT)
-> (VkHeadlessSurfaceCreateFlagsEXT
    -> Int -> VkHeadlessSurfaceCreateFlagsEXT)
-> VkHeadlessSurfaceCreateFlagsEXT
-> (Int -> VkHeadlessSurfaceCreateFlagsEXT)
-> (VkHeadlessSurfaceCreateFlagsEXT
    -> Int -> VkHeadlessSurfaceCreateFlagsEXT)
-> (VkHeadlessSurfaceCreateFlagsEXT
    -> Int -> VkHeadlessSurfaceCreateFlagsEXT)
-> (VkHeadlessSurfaceCreateFlagsEXT
    -> Int -> VkHeadlessSurfaceCreateFlagsEXT)
-> (VkHeadlessSurfaceCreateFlagsEXT -> Int -> Bool)
-> (VkHeadlessSurfaceCreateFlagsEXT -> Maybe Int)
-> (VkHeadlessSurfaceCreateFlagsEXT -> Int)
-> (VkHeadlessSurfaceCreateFlagsEXT -> Bool)
-> (VkHeadlessSurfaceCreateFlagsEXT
    -> Int -> VkHeadlessSurfaceCreateFlagsEXT)
-> (VkHeadlessSurfaceCreateFlagsEXT
    -> Int -> VkHeadlessSurfaceCreateFlagsEXT)
-> (VkHeadlessSurfaceCreateFlagsEXT
    -> Int -> VkHeadlessSurfaceCreateFlagsEXT)
-> (VkHeadlessSurfaceCreateFlagsEXT
    -> Int -> VkHeadlessSurfaceCreateFlagsEXT)
-> (VkHeadlessSurfaceCreateFlagsEXT
    -> Int -> VkHeadlessSurfaceCreateFlagsEXT)
-> (VkHeadlessSurfaceCreateFlagsEXT
    -> Int -> VkHeadlessSurfaceCreateFlagsEXT)
-> (VkHeadlessSurfaceCreateFlagsEXT -> Int)
-> Bits VkHeadlessSurfaceCreateFlagsEXT
Int -> VkHeadlessSurfaceCreateFlagsEXT
VkHeadlessSurfaceCreateFlagsEXT -> Bool
VkHeadlessSurfaceCreateFlagsEXT -> Int
VkHeadlessSurfaceCreateFlagsEXT -> Maybe Int
VkHeadlessSurfaceCreateFlagsEXT -> VkHeadlessSurfaceCreateFlagsEXT
VkHeadlessSurfaceCreateFlagsEXT -> Int -> Bool
VkHeadlessSurfaceCreateFlagsEXT
-> Int -> VkHeadlessSurfaceCreateFlagsEXT
VkHeadlessSurfaceCreateFlagsEXT
-> VkHeadlessSurfaceCreateFlagsEXT
-> VkHeadlessSurfaceCreateFlagsEXT
forall a.
Eq a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
popCount :: VkHeadlessSurfaceCreateFlagsEXT -> Int
$cpopCount :: VkHeadlessSurfaceCreateFlagsEXT -> Int
rotateR :: VkHeadlessSurfaceCreateFlagsEXT
-> Int -> VkHeadlessSurfaceCreateFlagsEXT
$crotateR :: VkHeadlessSurfaceCreateFlagsEXT
-> Int -> VkHeadlessSurfaceCreateFlagsEXT
rotateL :: VkHeadlessSurfaceCreateFlagsEXT
-> Int -> VkHeadlessSurfaceCreateFlagsEXT
$crotateL :: VkHeadlessSurfaceCreateFlagsEXT
-> Int -> VkHeadlessSurfaceCreateFlagsEXT
unsafeShiftR :: VkHeadlessSurfaceCreateFlagsEXT
-> Int -> VkHeadlessSurfaceCreateFlagsEXT
$cunsafeShiftR :: VkHeadlessSurfaceCreateFlagsEXT
-> Int -> VkHeadlessSurfaceCreateFlagsEXT
shiftR :: VkHeadlessSurfaceCreateFlagsEXT
-> Int -> VkHeadlessSurfaceCreateFlagsEXT
$cshiftR :: VkHeadlessSurfaceCreateFlagsEXT
-> Int -> VkHeadlessSurfaceCreateFlagsEXT
unsafeShiftL :: VkHeadlessSurfaceCreateFlagsEXT
-> Int -> VkHeadlessSurfaceCreateFlagsEXT
$cunsafeShiftL :: VkHeadlessSurfaceCreateFlagsEXT
-> Int -> VkHeadlessSurfaceCreateFlagsEXT
shiftL :: VkHeadlessSurfaceCreateFlagsEXT
-> Int -> VkHeadlessSurfaceCreateFlagsEXT
$cshiftL :: VkHeadlessSurfaceCreateFlagsEXT
-> Int -> VkHeadlessSurfaceCreateFlagsEXT
isSigned :: VkHeadlessSurfaceCreateFlagsEXT -> Bool
$cisSigned :: VkHeadlessSurfaceCreateFlagsEXT -> Bool
bitSize :: VkHeadlessSurfaceCreateFlagsEXT -> Int
$cbitSize :: VkHeadlessSurfaceCreateFlagsEXT -> Int
bitSizeMaybe :: VkHeadlessSurfaceCreateFlagsEXT -> Maybe Int
$cbitSizeMaybe :: VkHeadlessSurfaceCreateFlagsEXT -> Maybe Int
testBit :: VkHeadlessSurfaceCreateFlagsEXT -> Int -> Bool
$ctestBit :: VkHeadlessSurfaceCreateFlagsEXT -> Int -> Bool
complementBit :: VkHeadlessSurfaceCreateFlagsEXT
-> Int -> VkHeadlessSurfaceCreateFlagsEXT
$ccomplementBit :: VkHeadlessSurfaceCreateFlagsEXT
-> Int -> VkHeadlessSurfaceCreateFlagsEXT
clearBit :: VkHeadlessSurfaceCreateFlagsEXT
-> Int -> VkHeadlessSurfaceCreateFlagsEXT
$cclearBit :: VkHeadlessSurfaceCreateFlagsEXT
-> Int -> VkHeadlessSurfaceCreateFlagsEXT
setBit :: VkHeadlessSurfaceCreateFlagsEXT
-> Int -> VkHeadlessSurfaceCreateFlagsEXT
$csetBit :: VkHeadlessSurfaceCreateFlagsEXT
-> Int -> VkHeadlessSurfaceCreateFlagsEXT
bit :: Int -> VkHeadlessSurfaceCreateFlagsEXT
$cbit :: Int -> VkHeadlessSurfaceCreateFlagsEXT
zeroBits :: VkHeadlessSurfaceCreateFlagsEXT
$czeroBits :: VkHeadlessSurfaceCreateFlagsEXT
rotate :: VkHeadlessSurfaceCreateFlagsEXT
-> Int -> VkHeadlessSurfaceCreateFlagsEXT
$crotate :: VkHeadlessSurfaceCreateFlagsEXT
-> Int -> VkHeadlessSurfaceCreateFlagsEXT
shift :: VkHeadlessSurfaceCreateFlagsEXT
-> Int -> VkHeadlessSurfaceCreateFlagsEXT
$cshift :: VkHeadlessSurfaceCreateFlagsEXT
-> Int -> VkHeadlessSurfaceCreateFlagsEXT
complement :: VkHeadlessSurfaceCreateFlagsEXT -> VkHeadlessSurfaceCreateFlagsEXT
$ccomplement :: VkHeadlessSurfaceCreateFlagsEXT -> VkHeadlessSurfaceCreateFlagsEXT
xor :: VkHeadlessSurfaceCreateFlagsEXT
-> VkHeadlessSurfaceCreateFlagsEXT
-> VkHeadlessSurfaceCreateFlagsEXT
$cxor :: VkHeadlessSurfaceCreateFlagsEXT
-> VkHeadlessSurfaceCreateFlagsEXT
-> VkHeadlessSurfaceCreateFlagsEXT
.|. :: VkHeadlessSurfaceCreateFlagsEXT
-> VkHeadlessSurfaceCreateFlagsEXT
-> VkHeadlessSurfaceCreateFlagsEXT
$c.|. :: VkHeadlessSurfaceCreateFlagsEXT
-> VkHeadlessSurfaceCreateFlagsEXT
-> VkHeadlessSurfaceCreateFlagsEXT
.&. :: VkHeadlessSurfaceCreateFlagsEXT
-> VkHeadlessSurfaceCreateFlagsEXT
-> VkHeadlessSurfaceCreateFlagsEXT
$c.&. :: VkHeadlessSurfaceCreateFlagsEXT
-> VkHeadlessSurfaceCreateFlagsEXT
-> VkHeadlessSurfaceCreateFlagsEXT
Bits, Bits VkHeadlessSurfaceCreateFlagsEXT
Bits VkHeadlessSurfaceCreateFlagsEXT
-> (VkHeadlessSurfaceCreateFlagsEXT -> Int)
-> (VkHeadlessSurfaceCreateFlagsEXT -> Int)
-> (VkHeadlessSurfaceCreateFlagsEXT -> Int)
-> FiniteBits VkHeadlessSurfaceCreateFlagsEXT
VkHeadlessSurfaceCreateFlagsEXT -> Int
forall b.
Bits b -> (b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
countTrailingZeros :: VkHeadlessSurfaceCreateFlagsEXT -> Int
$ccountTrailingZeros :: VkHeadlessSurfaceCreateFlagsEXT -> Int
countLeadingZeros :: VkHeadlessSurfaceCreateFlagsEXT -> Int
$ccountLeadingZeros :: VkHeadlessSurfaceCreateFlagsEXT -> Int
finiteBitSize :: VkHeadlessSurfaceCreateFlagsEXT -> Int
$cfiniteBitSize :: VkHeadlessSurfaceCreateFlagsEXT -> Int
FiniteBits, Ptr VkHeadlessSurfaceCreateFlagsEXT
-> IO VkHeadlessSurfaceCreateFlagsEXT
Ptr VkHeadlessSurfaceCreateFlagsEXT
-> Int -> IO VkHeadlessSurfaceCreateFlagsEXT
Ptr VkHeadlessSurfaceCreateFlagsEXT
-> Int -> VkHeadlessSurfaceCreateFlagsEXT -> IO ()
Ptr VkHeadlessSurfaceCreateFlagsEXT
-> VkHeadlessSurfaceCreateFlagsEXT -> IO ()
VkHeadlessSurfaceCreateFlagsEXT -> Int
(VkHeadlessSurfaceCreateFlagsEXT -> Int)
-> (VkHeadlessSurfaceCreateFlagsEXT -> Int)
-> (Ptr VkHeadlessSurfaceCreateFlagsEXT
    -> Int -> IO VkHeadlessSurfaceCreateFlagsEXT)
-> (Ptr VkHeadlessSurfaceCreateFlagsEXT
    -> Int -> VkHeadlessSurfaceCreateFlagsEXT -> IO ())
-> (forall b. Ptr b -> Int -> IO VkHeadlessSurfaceCreateFlagsEXT)
-> (forall b.
    Ptr b -> Int -> VkHeadlessSurfaceCreateFlagsEXT -> IO ())
-> (Ptr VkHeadlessSurfaceCreateFlagsEXT
    -> IO VkHeadlessSurfaceCreateFlagsEXT)
-> (Ptr VkHeadlessSurfaceCreateFlagsEXT
    -> VkHeadlessSurfaceCreateFlagsEXT -> IO ())
-> Storable VkHeadlessSurfaceCreateFlagsEXT
forall b. Ptr b -> Int -> IO VkHeadlessSurfaceCreateFlagsEXT
forall b. Ptr b -> Int -> VkHeadlessSurfaceCreateFlagsEXT -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr VkHeadlessSurfaceCreateFlagsEXT
-> VkHeadlessSurfaceCreateFlagsEXT -> IO ()
$cpoke :: Ptr VkHeadlessSurfaceCreateFlagsEXT
-> VkHeadlessSurfaceCreateFlagsEXT -> IO ()
peek :: Ptr VkHeadlessSurfaceCreateFlagsEXT
-> IO VkHeadlessSurfaceCreateFlagsEXT
$cpeek :: Ptr VkHeadlessSurfaceCreateFlagsEXT
-> IO VkHeadlessSurfaceCreateFlagsEXT
pokeByteOff :: forall b. Ptr b -> Int -> VkHeadlessSurfaceCreateFlagsEXT -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> VkHeadlessSurfaceCreateFlagsEXT -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO VkHeadlessSurfaceCreateFlagsEXT
$cpeekByteOff :: forall b. Ptr b -> Int -> IO VkHeadlessSurfaceCreateFlagsEXT
pokeElemOff :: Ptr VkHeadlessSurfaceCreateFlagsEXT
-> Int -> VkHeadlessSurfaceCreateFlagsEXT -> IO ()
$cpokeElemOff :: Ptr VkHeadlessSurfaceCreateFlagsEXT
-> Int -> VkHeadlessSurfaceCreateFlagsEXT -> IO ()
peekElemOff :: Ptr VkHeadlessSurfaceCreateFlagsEXT
-> Int -> IO VkHeadlessSurfaceCreateFlagsEXT
$cpeekElemOff :: Ptr VkHeadlessSurfaceCreateFlagsEXT
-> Int -> IO VkHeadlessSurfaceCreateFlagsEXT
alignment :: VkHeadlessSurfaceCreateFlagsEXT -> Int
$calignment :: VkHeadlessSurfaceCreateFlagsEXT -> Int
sizeOf :: VkHeadlessSurfaceCreateFlagsEXT -> Int
$csizeOf :: VkHeadlessSurfaceCreateFlagsEXT -> Int
Storable)

instance Show VkHeadlessSurfaceCreateFlagsEXT where
    {-# INLINE showsPrec #-}
    showsPrec :: Int -> VkHeadlessSurfaceCreateFlagsEXT -> ShowS
showsPrec = (Int -> VkFlags -> ShowS)
-> Int -> VkHeadlessSurfaceCreateFlagsEXT -> ShowS
coerce (Int -> VkFlags -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec :: Int -> VkFlags -> ShowS)

instance Read VkHeadlessSurfaceCreateFlagsEXT where
    {-# INLINE readsPrec #-}
    readsPrec :: Int -> ReadS VkHeadlessSurfaceCreateFlagsEXT
readsPrec = (Int -> ReadS VkFlags)
-> Int -> ReadS VkHeadlessSurfaceCreateFlagsEXT
coerce (Int -> ReadS VkFlags
forall a. Read a => Int -> ReadS a
readsPrec :: Int -> ReadS VkFlags)

newtype VkIOSSurfaceCreateFlagsMVK = VkIOSSurfaceCreateFlagsMVK VkFlags
                                     deriving (VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK -> Bool
(VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK -> Bool)
-> (VkIOSSurfaceCreateFlagsMVK
    -> VkIOSSurfaceCreateFlagsMVK -> Bool)
-> Eq VkIOSSurfaceCreateFlagsMVK
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK -> Bool
$c/= :: VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK -> Bool
== :: VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK -> Bool
$c== :: VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK -> Bool
Eq, Eq VkIOSSurfaceCreateFlagsMVK
Eq VkIOSSurfaceCreateFlagsMVK
-> (VkIOSSurfaceCreateFlagsMVK
    -> VkIOSSurfaceCreateFlagsMVK -> Ordering)
-> (VkIOSSurfaceCreateFlagsMVK
    -> VkIOSSurfaceCreateFlagsMVK -> Bool)
-> (VkIOSSurfaceCreateFlagsMVK
    -> VkIOSSurfaceCreateFlagsMVK -> Bool)
-> (VkIOSSurfaceCreateFlagsMVK
    -> VkIOSSurfaceCreateFlagsMVK -> Bool)
-> (VkIOSSurfaceCreateFlagsMVK
    -> VkIOSSurfaceCreateFlagsMVK -> Bool)
-> (VkIOSSurfaceCreateFlagsMVK
    -> VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK)
-> (VkIOSSurfaceCreateFlagsMVK
    -> VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK)
-> Ord VkIOSSurfaceCreateFlagsMVK
VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK -> Bool
VkIOSSurfaceCreateFlagsMVK
-> VkIOSSurfaceCreateFlagsMVK -> Ordering
VkIOSSurfaceCreateFlagsMVK
-> VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: VkIOSSurfaceCreateFlagsMVK
-> VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK
$cmin :: VkIOSSurfaceCreateFlagsMVK
-> VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK
max :: VkIOSSurfaceCreateFlagsMVK
-> VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK
$cmax :: VkIOSSurfaceCreateFlagsMVK
-> VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK
>= :: VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK -> Bool
$c>= :: VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK -> Bool
> :: VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK -> Bool
$c> :: VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK -> Bool
<= :: VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK -> Bool
$c<= :: VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK -> Bool
< :: VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK -> Bool
$c< :: VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK -> Bool
compare :: VkIOSSurfaceCreateFlagsMVK
-> VkIOSSurfaceCreateFlagsMVK -> Ordering
$ccompare :: VkIOSSurfaceCreateFlagsMVK
-> VkIOSSurfaceCreateFlagsMVK -> Ordering
Ord, Int -> VkIOSSurfaceCreateFlagsMVK
VkIOSSurfaceCreateFlagsMVK -> Int
VkIOSSurfaceCreateFlagsMVK -> [VkIOSSurfaceCreateFlagsMVK]
VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK
VkIOSSurfaceCreateFlagsMVK
-> VkIOSSurfaceCreateFlagsMVK -> [VkIOSSurfaceCreateFlagsMVK]
VkIOSSurfaceCreateFlagsMVK
-> VkIOSSurfaceCreateFlagsMVK
-> VkIOSSurfaceCreateFlagsMVK
-> [VkIOSSurfaceCreateFlagsMVK]
(VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK)
-> (VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK)
-> (Int -> VkIOSSurfaceCreateFlagsMVK)
-> (VkIOSSurfaceCreateFlagsMVK -> Int)
-> (VkIOSSurfaceCreateFlagsMVK -> [VkIOSSurfaceCreateFlagsMVK])
-> (VkIOSSurfaceCreateFlagsMVK
    -> VkIOSSurfaceCreateFlagsMVK -> [VkIOSSurfaceCreateFlagsMVK])
-> (VkIOSSurfaceCreateFlagsMVK
    -> VkIOSSurfaceCreateFlagsMVK -> [VkIOSSurfaceCreateFlagsMVK])
-> (VkIOSSurfaceCreateFlagsMVK
    -> VkIOSSurfaceCreateFlagsMVK
    -> VkIOSSurfaceCreateFlagsMVK
    -> [VkIOSSurfaceCreateFlagsMVK])
-> Enum VkIOSSurfaceCreateFlagsMVK
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: VkIOSSurfaceCreateFlagsMVK
-> VkIOSSurfaceCreateFlagsMVK
-> VkIOSSurfaceCreateFlagsMVK
-> [VkIOSSurfaceCreateFlagsMVK]
$cenumFromThenTo :: VkIOSSurfaceCreateFlagsMVK
-> VkIOSSurfaceCreateFlagsMVK
-> VkIOSSurfaceCreateFlagsMVK
-> [VkIOSSurfaceCreateFlagsMVK]
enumFromTo :: VkIOSSurfaceCreateFlagsMVK
-> VkIOSSurfaceCreateFlagsMVK -> [VkIOSSurfaceCreateFlagsMVK]
$cenumFromTo :: VkIOSSurfaceCreateFlagsMVK
-> VkIOSSurfaceCreateFlagsMVK -> [VkIOSSurfaceCreateFlagsMVK]
enumFromThen :: VkIOSSurfaceCreateFlagsMVK
-> VkIOSSurfaceCreateFlagsMVK -> [VkIOSSurfaceCreateFlagsMVK]
$cenumFromThen :: VkIOSSurfaceCreateFlagsMVK
-> VkIOSSurfaceCreateFlagsMVK -> [VkIOSSurfaceCreateFlagsMVK]
enumFrom :: VkIOSSurfaceCreateFlagsMVK -> [VkIOSSurfaceCreateFlagsMVK]
$cenumFrom :: VkIOSSurfaceCreateFlagsMVK -> [VkIOSSurfaceCreateFlagsMVK]
fromEnum :: VkIOSSurfaceCreateFlagsMVK -> Int
$cfromEnum :: VkIOSSurfaceCreateFlagsMVK -> Int
toEnum :: Int -> VkIOSSurfaceCreateFlagsMVK
$ctoEnum :: Int -> VkIOSSurfaceCreateFlagsMVK
pred :: VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK
$cpred :: VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK
succ :: VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK
$csucc :: VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK
Enum, Eq VkIOSSurfaceCreateFlagsMVK
VkIOSSurfaceCreateFlagsMVK
Eq VkIOSSurfaceCreateFlagsMVK
-> (VkIOSSurfaceCreateFlagsMVK
    -> VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK)
-> (VkIOSSurfaceCreateFlagsMVK
    -> VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK)
-> (VkIOSSurfaceCreateFlagsMVK
    -> VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK)
-> (VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK)
-> (VkIOSSurfaceCreateFlagsMVK
    -> Int -> VkIOSSurfaceCreateFlagsMVK)
-> (VkIOSSurfaceCreateFlagsMVK
    -> Int -> VkIOSSurfaceCreateFlagsMVK)
-> VkIOSSurfaceCreateFlagsMVK
-> (Int -> VkIOSSurfaceCreateFlagsMVK)
-> (VkIOSSurfaceCreateFlagsMVK
    -> Int -> VkIOSSurfaceCreateFlagsMVK)
-> (VkIOSSurfaceCreateFlagsMVK
    -> Int -> VkIOSSurfaceCreateFlagsMVK)
-> (VkIOSSurfaceCreateFlagsMVK
    -> Int -> VkIOSSurfaceCreateFlagsMVK)
-> (VkIOSSurfaceCreateFlagsMVK -> Int -> Bool)
-> (VkIOSSurfaceCreateFlagsMVK -> Maybe Int)
-> (VkIOSSurfaceCreateFlagsMVK -> Int)
-> (VkIOSSurfaceCreateFlagsMVK -> Bool)
-> (VkIOSSurfaceCreateFlagsMVK
    -> Int -> VkIOSSurfaceCreateFlagsMVK)
-> (VkIOSSurfaceCreateFlagsMVK
    -> Int -> VkIOSSurfaceCreateFlagsMVK)
-> (VkIOSSurfaceCreateFlagsMVK
    -> Int -> VkIOSSurfaceCreateFlagsMVK)
-> (VkIOSSurfaceCreateFlagsMVK
    -> Int -> VkIOSSurfaceCreateFlagsMVK)
-> (VkIOSSurfaceCreateFlagsMVK
    -> Int -> VkIOSSurfaceCreateFlagsMVK)
-> (VkIOSSurfaceCreateFlagsMVK
    -> Int -> VkIOSSurfaceCreateFlagsMVK)
-> (VkIOSSurfaceCreateFlagsMVK -> Int)
-> Bits VkIOSSurfaceCreateFlagsMVK
Int -> VkIOSSurfaceCreateFlagsMVK
VkIOSSurfaceCreateFlagsMVK -> Bool
VkIOSSurfaceCreateFlagsMVK -> Int
VkIOSSurfaceCreateFlagsMVK -> Maybe Int
VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK
VkIOSSurfaceCreateFlagsMVK -> Int -> Bool
VkIOSSurfaceCreateFlagsMVK -> Int -> VkIOSSurfaceCreateFlagsMVK
VkIOSSurfaceCreateFlagsMVK
-> VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK
forall a.
Eq a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
popCount :: VkIOSSurfaceCreateFlagsMVK -> Int
$cpopCount :: VkIOSSurfaceCreateFlagsMVK -> Int
rotateR :: VkIOSSurfaceCreateFlagsMVK -> Int -> VkIOSSurfaceCreateFlagsMVK
$crotateR :: VkIOSSurfaceCreateFlagsMVK -> Int -> VkIOSSurfaceCreateFlagsMVK
rotateL :: VkIOSSurfaceCreateFlagsMVK -> Int -> VkIOSSurfaceCreateFlagsMVK
$crotateL :: VkIOSSurfaceCreateFlagsMVK -> Int -> VkIOSSurfaceCreateFlagsMVK
unsafeShiftR :: VkIOSSurfaceCreateFlagsMVK -> Int -> VkIOSSurfaceCreateFlagsMVK
$cunsafeShiftR :: VkIOSSurfaceCreateFlagsMVK -> Int -> VkIOSSurfaceCreateFlagsMVK
shiftR :: VkIOSSurfaceCreateFlagsMVK -> Int -> VkIOSSurfaceCreateFlagsMVK
$cshiftR :: VkIOSSurfaceCreateFlagsMVK -> Int -> VkIOSSurfaceCreateFlagsMVK
unsafeShiftL :: VkIOSSurfaceCreateFlagsMVK -> Int -> VkIOSSurfaceCreateFlagsMVK
$cunsafeShiftL :: VkIOSSurfaceCreateFlagsMVK -> Int -> VkIOSSurfaceCreateFlagsMVK
shiftL :: VkIOSSurfaceCreateFlagsMVK -> Int -> VkIOSSurfaceCreateFlagsMVK
$cshiftL :: VkIOSSurfaceCreateFlagsMVK -> Int -> VkIOSSurfaceCreateFlagsMVK
isSigned :: VkIOSSurfaceCreateFlagsMVK -> Bool
$cisSigned :: VkIOSSurfaceCreateFlagsMVK -> Bool
bitSize :: VkIOSSurfaceCreateFlagsMVK -> Int
$cbitSize :: VkIOSSurfaceCreateFlagsMVK -> Int
bitSizeMaybe :: VkIOSSurfaceCreateFlagsMVK -> Maybe Int
$cbitSizeMaybe :: VkIOSSurfaceCreateFlagsMVK -> Maybe Int
testBit :: VkIOSSurfaceCreateFlagsMVK -> Int -> Bool
$ctestBit :: VkIOSSurfaceCreateFlagsMVK -> Int -> Bool
complementBit :: VkIOSSurfaceCreateFlagsMVK -> Int -> VkIOSSurfaceCreateFlagsMVK
$ccomplementBit :: VkIOSSurfaceCreateFlagsMVK -> Int -> VkIOSSurfaceCreateFlagsMVK
clearBit :: VkIOSSurfaceCreateFlagsMVK -> Int -> VkIOSSurfaceCreateFlagsMVK
$cclearBit :: VkIOSSurfaceCreateFlagsMVK -> Int -> VkIOSSurfaceCreateFlagsMVK
setBit :: VkIOSSurfaceCreateFlagsMVK -> Int -> VkIOSSurfaceCreateFlagsMVK
$csetBit :: VkIOSSurfaceCreateFlagsMVK -> Int -> VkIOSSurfaceCreateFlagsMVK
bit :: Int -> VkIOSSurfaceCreateFlagsMVK
$cbit :: Int -> VkIOSSurfaceCreateFlagsMVK
zeroBits :: VkIOSSurfaceCreateFlagsMVK
$czeroBits :: VkIOSSurfaceCreateFlagsMVK
rotate :: VkIOSSurfaceCreateFlagsMVK -> Int -> VkIOSSurfaceCreateFlagsMVK
$crotate :: VkIOSSurfaceCreateFlagsMVK -> Int -> VkIOSSurfaceCreateFlagsMVK
shift :: VkIOSSurfaceCreateFlagsMVK -> Int -> VkIOSSurfaceCreateFlagsMVK
$cshift :: VkIOSSurfaceCreateFlagsMVK -> Int -> VkIOSSurfaceCreateFlagsMVK
complement :: VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK
$ccomplement :: VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK
xor :: VkIOSSurfaceCreateFlagsMVK
-> VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK
$cxor :: VkIOSSurfaceCreateFlagsMVK
-> VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK
.|. :: VkIOSSurfaceCreateFlagsMVK
-> VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK
$c.|. :: VkIOSSurfaceCreateFlagsMVK
-> VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK
.&. :: VkIOSSurfaceCreateFlagsMVK
-> VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK
$c.&. :: VkIOSSurfaceCreateFlagsMVK
-> VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK
Bits, Bits VkIOSSurfaceCreateFlagsMVK
Bits VkIOSSurfaceCreateFlagsMVK
-> (VkIOSSurfaceCreateFlagsMVK -> Int)
-> (VkIOSSurfaceCreateFlagsMVK -> Int)
-> (VkIOSSurfaceCreateFlagsMVK -> Int)
-> FiniteBits VkIOSSurfaceCreateFlagsMVK
VkIOSSurfaceCreateFlagsMVK -> Int
forall b.
Bits b -> (b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
countTrailingZeros :: VkIOSSurfaceCreateFlagsMVK -> Int
$ccountTrailingZeros :: VkIOSSurfaceCreateFlagsMVK -> Int
countLeadingZeros :: VkIOSSurfaceCreateFlagsMVK -> Int
$ccountLeadingZeros :: VkIOSSurfaceCreateFlagsMVK -> Int
finiteBitSize :: VkIOSSurfaceCreateFlagsMVK -> Int
$cfiniteBitSize :: VkIOSSurfaceCreateFlagsMVK -> Int
FiniteBits, Ptr VkIOSSurfaceCreateFlagsMVK -> IO VkIOSSurfaceCreateFlagsMVK
Ptr VkIOSSurfaceCreateFlagsMVK
-> Int -> IO VkIOSSurfaceCreateFlagsMVK
Ptr VkIOSSurfaceCreateFlagsMVK
-> Int -> VkIOSSurfaceCreateFlagsMVK -> IO ()
Ptr VkIOSSurfaceCreateFlagsMVK
-> VkIOSSurfaceCreateFlagsMVK -> IO ()
VkIOSSurfaceCreateFlagsMVK -> Int
(VkIOSSurfaceCreateFlagsMVK -> Int)
-> (VkIOSSurfaceCreateFlagsMVK -> Int)
-> (Ptr VkIOSSurfaceCreateFlagsMVK
    -> Int -> IO VkIOSSurfaceCreateFlagsMVK)
-> (Ptr VkIOSSurfaceCreateFlagsMVK
    -> Int -> VkIOSSurfaceCreateFlagsMVK -> IO ())
-> (forall b. Ptr b -> Int -> IO VkIOSSurfaceCreateFlagsMVK)
-> (forall b. Ptr b -> Int -> VkIOSSurfaceCreateFlagsMVK -> IO ())
-> (Ptr VkIOSSurfaceCreateFlagsMVK
    -> IO VkIOSSurfaceCreateFlagsMVK)
-> (Ptr VkIOSSurfaceCreateFlagsMVK
    -> VkIOSSurfaceCreateFlagsMVK -> IO ())
-> Storable VkIOSSurfaceCreateFlagsMVK
forall b. Ptr b -> Int -> IO VkIOSSurfaceCreateFlagsMVK
forall b. Ptr b -> Int -> VkIOSSurfaceCreateFlagsMVK -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr VkIOSSurfaceCreateFlagsMVK
-> VkIOSSurfaceCreateFlagsMVK -> IO ()
$cpoke :: Ptr VkIOSSurfaceCreateFlagsMVK
-> VkIOSSurfaceCreateFlagsMVK -> IO ()
peek :: Ptr VkIOSSurfaceCreateFlagsMVK -> IO VkIOSSurfaceCreateFlagsMVK
$cpeek :: Ptr VkIOSSurfaceCreateFlagsMVK -> IO VkIOSSurfaceCreateFlagsMVK
pokeByteOff :: forall b. Ptr b -> Int -> VkIOSSurfaceCreateFlagsMVK -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> VkIOSSurfaceCreateFlagsMVK -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO VkIOSSurfaceCreateFlagsMVK
$cpeekByteOff :: forall b. Ptr b -> Int -> IO VkIOSSurfaceCreateFlagsMVK
pokeElemOff :: Ptr VkIOSSurfaceCreateFlagsMVK
-> Int -> VkIOSSurfaceCreateFlagsMVK -> IO ()
$cpokeElemOff :: Ptr VkIOSSurfaceCreateFlagsMVK
-> Int -> VkIOSSurfaceCreateFlagsMVK -> IO ()
peekElemOff :: Ptr VkIOSSurfaceCreateFlagsMVK
-> Int -> IO VkIOSSurfaceCreateFlagsMVK
$cpeekElemOff :: Ptr VkIOSSurfaceCreateFlagsMVK
-> Int -> IO VkIOSSurfaceCreateFlagsMVK
alignment :: VkIOSSurfaceCreateFlagsMVK -> Int
$calignment :: VkIOSSurfaceCreateFlagsMVK -> Int
sizeOf :: VkIOSSurfaceCreateFlagsMVK -> Int
$csizeOf :: VkIOSSurfaceCreateFlagsMVK -> Int
Storable)

instance Show VkIOSSurfaceCreateFlagsMVK where
    {-# INLINE showsPrec #-}
    showsPrec :: Int -> VkIOSSurfaceCreateFlagsMVK -> ShowS
showsPrec = (Int -> VkFlags -> ShowS)
-> Int -> VkIOSSurfaceCreateFlagsMVK -> ShowS
coerce (Int -> VkFlags -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec :: Int -> VkFlags -> ShowS)

instance Read VkIOSSurfaceCreateFlagsMVK where
    {-# INLINE readsPrec #-}
    readsPrec :: Int -> ReadS VkIOSSurfaceCreateFlagsMVK
readsPrec = (Int -> ReadS VkFlags) -> Int -> ReadS VkIOSSurfaceCreateFlagsMVK
coerce (Int -> ReadS VkFlags
forall a. Read a => Int -> ReadS a
readsPrec :: Int -> ReadS VkFlags)

newtype VkImagePipeSurfaceCreateFlagsFUCHSIA = VkImagePipeSurfaceCreateFlagsFUCHSIA VkFlags
                                               deriving (VkImagePipeSurfaceCreateFlagsFUCHSIA
-> VkImagePipeSurfaceCreateFlagsFUCHSIA -> Bool
(VkImagePipeSurfaceCreateFlagsFUCHSIA
 -> VkImagePipeSurfaceCreateFlagsFUCHSIA -> Bool)
-> (VkImagePipeSurfaceCreateFlagsFUCHSIA
    -> VkImagePipeSurfaceCreateFlagsFUCHSIA -> Bool)
-> Eq VkImagePipeSurfaceCreateFlagsFUCHSIA
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VkImagePipeSurfaceCreateFlagsFUCHSIA
-> VkImagePipeSurfaceCreateFlagsFUCHSIA -> Bool
$c/= :: VkImagePipeSurfaceCreateFlagsFUCHSIA
-> VkImagePipeSurfaceCreateFlagsFUCHSIA -> Bool
== :: VkImagePipeSurfaceCreateFlagsFUCHSIA
-> VkImagePipeSurfaceCreateFlagsFUCHSIA -> Bool
$c== :: VkImagePipeSurfaceCreateFlagsFUCHSIA
-> VkImagePipeSurfaceCreateFlagsFUCHSIA -> Bool
Eq, Eq VkImagePipeSurfaceCreateFlagsFUCHSIA
Eq VkImagePipeSurfaceCreateFlagsFUCHSIA
-> (VkImagePipeSurfaceCreateFlagsFUCHSIA
    -> VkImagePipeSurfaceCreateFlagsFUCHSIA -> Ordering)
-> (VkImagePipeSurfaceCreateFlagsFUCHSIA
    -> VkImagePipeSurfaceCreateFlagsFUCHSIA -> Bool)
-> (VkImagePipeSurfaceCreateFlagsFUCHSIA
    -> VkImagePipeSurfaceCreateFlagsFUCHSIA -> Bool)
-> (VkImagePipeSurfaceCreateFlagsFUCHSIA
    -> VkImagePipeSurfaceCreateFlagsFUCHSIA -> Bool)
-> (VkImagePipeSurfaceCreateFlagsFUCHSIA
    -> VkImagePipeSurfaceCreateFlagsFUCHSIA -> Bool)
-> (VkImagePipeSurfaceCreateFlagsFUCHSIA
    -> VkImagePipeSurfaceCreateFlagsFUCHSIA
    -> VkImagePipeSurfaceCreateFlagsFUCHSIA)
-> (VkImagePipeSurfaceCreateFlagsFUCHSIA
    -> VkImagePipeSurfaceCreateFlagsFUCHSIA
    -> VkImagePipeSurfaceCreateFlagsFUCHSIA)
-> Ord VkImagePipeSurfaceCreateFlagsFUCHSIA
VkImagePipeSurfaceCreateFlagsFUCHSIA
-> VkImagePipeSurfaceCreateFlagsFUCHSIA -> Bool
VkImagePipeSurfaceCreateFlagsFUCHSIA
-> VkImagePipeSurfaceCreateFlagsFUCHSIA -> Ordering
VkImagePipeSurfaceCreateFlagsFUCHSIA
-> VkImagePipeSurfaceCreateFlagsFUCHSIA
-> VkImagePipeSurfaceCreateFlagsFUCHSIA
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: VkImagePipeSurfaceCreateFlagsFUCHSIA
-> VkImagePipeSurfaceCreateFlagsFUCHSIA
-> VkImagePipeSurfaceCreateFlagsFUCHSIA
$cmin :: VkImagePipeSurfaceCreateFlagsFUCHSIA
-> VkImagePipeSurfaceCreateFlagsFUCHSIA
-> VkImagePipeSurfaceCreateFlagsFUCHSIA
max :: VkImagePipeSurfaceCreateFlagsFUCHSIA
-> VkImagePipeSurfaceCreateFlagsFUCHSIA
-> VkImagePipeSurfaceCreateFlagsFUCHSIA
$cmax :: VkImagePipeSurfaceCreateFlagsFUCHSIA
-> VkImagePipeSurfaceCreateFlagsFUCHSIA
-> VkImagePipeSurfaceCreateFlagsFUCHSIA
>= :: VkImagePipeSurfaceCreateFlagsFUCHSIA
-> VkImagePipeSurfaceCreateFlagsFUCHSIA -> Bool
$c>= :: VkImagePipeSurfaceCreateFlagsFUCHSIA
-> VkImagePipeSurfaceCreateFlagsFUCHSIA -> Bool
> :: VkImagePipeSurfaceCreateFlagsFUCHSIA
-> VkImagePipeSurfaceCreateFlagsFUCHSIA -> Bool
$c> :: VkImagePipeSurfaceCreateFlagsFUCHSIA
-> VkImagePipeSurfaceCreateFlagsFUCHSIA -> Bool
<= :: VkImagePipeSurfaceCreateFlagsFUCHSIA
-> VkImagePipeSurfaceCreateFlagsFUCHSIA -> Bool
$c<= :: VkImagePipeSurfaceCreateFlagsFUCHSIA
-> VkImagePipeSurfaceCreateFlagsFUCHSIA -> Bool
< :: VkImagePipeSurfaceCreateFlagsFUCHSIA
-> VkImagePipeSurfaceCreateFlagsFUCHSIA -> Bool
$c< :: VkImagePipeSurfaceCreateFlagsFUCHSIA
-> VkImagePipeSurfaceCreateFlagsFUCHSIA -> Bool
compare :: VkImagePipeSurfaceCreateFlagsFUCHSIA
-> VkImagePipeSurfaceCreateFlagsFUCHSIA -> Ordering
$ccompare :: VkImagePipeSurfaceCreateFlagsFUCHSIA
-> VkImagePipeSurfaceCreateFlagsFUCHSIA -> Ordering
Ord, Int -> VkImagePipeSurfaceCreateFlagsFUCHSIA
VkImagePipeSurfaceCreateFlagsFUCHSIA -> Int
VkImagePipeSurfaceCreateFlagsFUCHSIA
-> [VkImagePipeSurfaceCreateFlagsFUCHSIA]
VkImagePipeSurfaceCreateFlagsFUCHSIA
-> VkImagePipeSurfaceCreateFlagsFUCHSIA
VkImagePipeSurfaceCreateFlagsFUCHSIA
-> VkImagePipeSurfaceCreateFlagsFUCHSIA
-> [VkImagePipeSurfaceCreateFlagsFUCHSIA]
VkImagePipeSurfaceCreateFlagsFUCHSIA
-> VkImagePipeSurfaceCreateFlagsFUCHSIA
-> VkImagePipeSurfaceCreateFlagsFUCHSIA
-> [VkImagePipeSurfaceCreateFlagsFUCHSIA]
(VkImagePipeSurfaceCreateFlagsFUCHSIA
 -> VkImagePipeSurfaceCreateFlagsFUCHSIA)
-> (VkImagePipeSurfaceCreateFlagsFUCHSIA
    -> VkImagePipeSurfaceCreateFlagsFUCHSIA)
-> (Int -> VkImagePipeSurfaceCreateFlagsFUCHSIA)
-> (VkImagePipeSurfaceCreateFlagsFUCHSIA -> Int)
-> (VkImagePipeSurfaceCreateFlagsFUCHSIA
    -> [VkImagePipeSurfaceCreateFlagsFUCHSIA])
-> (VkImagePipeSurfaceCreateFlagsFUCHSIA
    -> VkImagePipeSurfaceCreateFlagsFUCHSIA
    -> [VkImagePipeSurfaceCreateFlagsFUCHSIA])
-> (VkImagePipeSurfaceCreateFlagsFUCHSIA
    -> VkImagePipeSurfaceCreateFlagsFUCHSIA
    -> [VkImagePipeSurfaceCreateFlagsFUCHSIA])
-> (VkImagePipeSurfaceCreateFlagsFUCHSIA
    -> VkImagePipeSurfaceCreateFlagsFUCHSIA
    -> VkImagePipeSurfaceCreateFlagsFUCHSIA
    -> [VkImagePipeSurfaceCreateFlagsFUCHSIA])
-> Enum VkImagePipeSurfaceCreateFlagsFUCHSIA
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: VkImagePipeSurfaceCreateFlagsFUCHSIA
-> VkImagePipeSurfaceCreateFlagsFUCHSIA
-> VkImagePipeSurfaceCreateFlagsFUCHSIA
-> [VkImagePipeSurfaceCreateFlagsFUCHSIA]
$cenumFromThenTo :: VkImagePipeSurfaceCreateFlagsFUCHSIA
-> VkImagePipeSurfaceCreateFlagsFUCHSIA
-> VkImagePipeSurfaceCreateFlagsFUCHSIA
-> [VkImagePipeSurfaceCreateFlagsFUCHSIA]
enumFromTo :: VkImagePipeSurfaceCreateFlagsFUCHSIA
-> VkImagePipeSurfaceCreateFlagsFUCHSIA
-> [VkImagePipeSurfaceCreateFlagsFUCHSIA]
$cenumFromTo :: VkImagePipeSurfaceCreateFlagsFUCHSIA
-> VkImagePipeSurfaceCreateFlagsFUCHSIA
-> [VkImagePipeSurfaceCreateFlagsFUCHSIA]
enumFromThen :: VkImagePipeSurfaceCreateFlagsFUCHSIA
-> VkImagePipeSurfaceCreateFlagsFUCHSIA
-> [VkImagePipeSurfaceCreateFlagsFUCHSIA]
$cenumFromThen :: VkImagePipeSurfaceCreateFlagsFUCHSIA
-> VkImagePipeSurfaceCreateFlagsFUCHSIA
-> [VkImagePipeSurfaceCreateFlagsFUCHSIA]
enumFrom :: VkImagePipeSurfaceCreateFlagsFUCHSIA
-> [VkImagePipeSurfaceCreateFlagsFUCHSIA]
$cenumFrom :: VkImagePipeSurfaceCreateFlagsFUCHSIA
-> [VkImagePipeSurfaceCreateFlagsFUCHSIA]
fromEnum :: VkImagePipeSurfaceCreateFlagsFUCHSIA -> Int
$cfromEnum :: VkImagePipeSurfaceCreateFlagsFUCHSIA -> Int
toEnum :: Int -> VkImagePipeSurfaceCreateFlagsFUCHSIA
$ctoEnum :: Int -> VkImagePipeSurfaceCreateFlagsFUCHSIA
pred :: VkImagePipeSurfaceCreateFlagsFUCHSIA
-> VkImagePipeSurfaceCreateFlagsFUCHSIA
$cpred :: VkImagePipeSurfaceCreateFlagsFUCHSIA
-> VkImagePipeSurfaceCreateFlagsFUCHSIA
succ :: VkImagePipeSurfaceCreateFlagsFUCHSIA
-> VkImagePipeSurfaceCreateFlagsFUCHSIA
$csucc :: VkImagePipeSurfaceCreateFlagsFUCHSIA
-> VkImagePipeSurfaceCreateFlagsFUCHSIA
Enum, Eq VkImagePipeSurfaceCreateFlagsFUCHSIA
VkImagePipeSurfaceCreateFlagsFUCHSIA
Eq VkImagePipeSurfaceCreateFlagsFUCHSIA
-> (VkImagePipeSurfaceCreateFlagsFUCHSIA
    -> VkImagePipeSurfaceCreateFlagsFUCHSIA
    -> VkImagePipeSurfaceCreateFlagsFUCHSIA)
-> (VkImagePipeSurfaceCreateFlagsFUCHSIA
    -> VkImagePipeSurfaceCreateFlagsFUCHSIA
    -> VkImagePipeSurfaceCreateFlagsFUCHSIA)
-> (VkImagePipeSurfaceCreateFlagsFUCHSIA
    -> VkImagePipeSurfaceCreateFlagsFUCHSIA
    -> VkImagePipeSurfaceCreateFlagsFUCHSIA)
-> (VkImagePipeSurfaceCreateFlagsFUCHSIA
    -> VkImagePipeSurfaceCreateFlagsFUCHSIA)
-> (VkImagePipeSurfaceCreateFlagsFUCHSIA
    -> Int -> VkImagePipeSurfaceCreateFlagsFUCHSIA)
-> (VkImagePipeSurfaceCreateFlagsFUCHSIA
    -> Int -> VkImagePipeSurfaceCreateFlagsFUCHSIA)
-> VkImagePipeSurfaceCreateFlagsFUCHSIA
-> (Int -> VkImagePipeSurfaceCreateFlagsFUCHSIA)
-> (VkImagePipeSurfaceCreateFlagsFUCHSIA
    -> Int -> VkImagePipeSurfaceCreateFlagsFUCHSIA)
-> (VkImagePipeSurfaceCreateFlagsFUCHSIA
    -> Int -> VkImagePipeSurfaceCreateFlagsFUCHSIA)
-> (VkImagePipeSurfaceCreateFlagsFUCHSIA
    -> Int -> VkImagePipeSurfaceCreateFlagsFUCHSIA)
-> (VkImagePipeSurfaceCreateFlagsFUCHSIA -> Int -> Bool)
-> (VkImagePipeSurfaceCreateFlagsFUCHSIA -> Maybe Int)
-> (VkImagePipeSurfaceCreateFlagsFUCHSIA -> Int)
-> (VkImagePipeSurfaceCreateFlagsFUCHSIA -> Bool)
-> (VkImagePipeSurfaceCreateFlagsFUCHSIA
    -> Int -> VkImagePipeSurfaceCreateFlagsFUCHSIA)
-> (VkImagePipeSurfaceCreateFlagsFUCHSIA
    -> Int -> VkImagePipeSurfaceCreateFlagsFUCHSIA)
-> (VkImagePipeSurfaceCreateFlagsFUCHSIA
    -> Int -> VkImagePipeSurfaceCreateFlagsFUCHSIA)
-> (VkImagePipeSurfaceCreateFlagsFUCHSIA
    -> Int -> VkImagePipeSurfaceCreateFlagsFUCHSIA)
-> (VkImagePipeSurfaceCreateFlagsFUCHSIA
    -> Int -> VkImagePipeSurfaceCreateFlagsFUCHSIA)
-> (VkImagePipeSurfaceCreateFlagsFUCHSIA
    -> Int -> VkImagePipeSurfaceCreateFlagsFUCHSIA)
-> (VkImagePipeSurfaceCreateFlagsFUCHSIA -> Int)
-> Bits VkImagePipeSurfaceCreateFlagsFUCHSIA
Int -> VkImagePipeSurfaceCreateFlagsFUCHSIA
VkImagePipeSurfaceCreateFlagsFUCHSIA -> Bool
VkImagePipeSurfaceCreateFlagsFUCHSIA -> Int
VkImagePipeSurfaceCreateFlagsFUCHSIA -> Maybe Int
VkImagePipeSurfaceCreateFlagsFUCHSIA
-> VkImagePipeSurfaceCreateFlagsFUCHSIA
VkImagePipeSurfaceCreateFlagsFUCHSIA -> Int -> Bool
VkImagePipeSurfaceCreateFlagsFUCHSIA
-> Int -> VkImagePipeSurfaceCreateFlagsFUCHSIA
VkImagePipeSurfaceCreateFlagsFUCHSIA
-> VkImagePipeSurfaceCreateFlagsFUCHSIA
-> VkImagePipeSurfaceCreateFlagsFUCHSIA
forall a.
Eq a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
popCount :: VkImagePipeSurfaceCreateFlagsFUCHSIA -> Int
$cpopCount :: VkImagePipeSurfaceCreateFlagsFUCHSIA -> Int
rotateR :: VkImagePipeSurfaceCreateFlagsFUCHSIA
-> Int -> VkImagePipeSurfaceCreateFlagsFUCHSIA
$crotateR :: VkImagePipeSurfaceCreateFlagsFUCHSIA
-> Int -> VkImagePipeSurfaceCreateFlagsFUCHSIA
rotateL :: VkImagePipeSurfaceCreateFlagsFUCHSIA
-> Int -> VkImagePipeSurfaceCreateFlagsFUCHSIA
$crotateL :: VkImagePipeSurfaceCreateFlagsFUCHSIA
-> Int -> VkImagePipeSurfaceCreateFlagsFUCHSIA
unsafeShiftR :: VkImagePipeSurfaceCreateFlagsFUCHSIA
-> Int -> VkImagePipeSurfaceCreateFlagsFUCHSIA
$cunsafeShiftR :: VkImagePipeSurfaceCreateFlagsFUCHSIA
-> Int -> VkImagePipeSurfaceCreateFlagsFUCHSIA
shiftR :: VkImagePipeSurfaceCreateFlagsFUCHSIA
-> Int -> VkImagePipeSurfaceCreateFlagsFUCHSIA
$cshiftR :: VkImagePipeSurfaceCreateFlagsFUCHSIA
-> Int -> VkImagePipeSurfaceCreateFlagsFUCHSIA
unsafeShiftL :: VkImagePipeSurfaceCreateFlagsFUCHSIA
-> Int -> VkImagePipeSurfaceCreateFlagsFUCHSIA
$cunsafeShiftL :: VkImagePipeSurfaceCreateFlagsFUCHSIA
-> Int -> VkImagePipeSurfaceCreateFlagsFUCHSIA
shiftL :: VkImagePipeSurfaceCreateFlagsFUCHSIA
-> Int -> VkImagePipeSurfaceCreateFlagsFUCHSIA
$cshiftL :: VkImagePipeSurfaceCreateFlagsFUCHSIA
-> Int -> VkImagePipeSurfaceCreateFlagsFUCHSIA
isSigned :: VkImagePipeSurfaceCreateFlagsFUCHSIA -> Bool
$cisSigned :: VkImagePipeSurfaceCreateFlagsFUCHSIA -> Bool
bitSize :: VkImagePipeSurfaceCreateFlagsFUCHSIA -> Int
$cbitSize :: VkImagePipeSurfaceCreateFlagsFUCHSIA -> Int
bitSizeMaybe :: VkImagePipeSurfaceCreateFlagsFUCHSIA -> Maybe Int
$cbitSizeMaybe :: VkImagePipeSurfaceCreateFlagsFUCHSIA -> Maybe Int
testBit :: VkImagePipeSurfaceCreateFlagsFUCHSIA -> Int -> Bool
$ctestBit :: VkImagePipeSurfaceCreateFlagsFUCHSIA -> Int -> Bool
complementBit :: VkImagePipeSurfaceCreateFlagsFUCHSIA
-> Int -> VkImagePipeSurfaceCreateFlagsFUCHSIA
$ccomplementBit :: VkImagePipeSurfaceCreateFlagsFUCHSIA
-> Int -> VkImagePipeSurfaceCreateFlagsFUCHSIA
clearBit :: VkImagePipeSurfaceCreateFlagsFUCHSIA
-> Int -> VkImagePipeSurfaceCreateFlagsFUCHSIA
$cclearBit :: VkImagePipeSurfaceCreateFlagsFUCHSIA
-> Int -> VkImagePipeSurfaceCreateFlagsFUCHSIA
setBit :: VkImagePipeSurfaceCreateFlagsFUCHSIA
-> Int -> VkImagePipeSurfaceCreateFlagsFUCHSIA
$csetBit :: VkImagePipeSurfaceCreateFlagsFUCHSIA
-> Int -> VkImagePipeSurfaceCreateFlagsFUCHSIA
bit :: Int -> VkImagePipeSurfaceCreateFlagsFUCHSIA
$cbit :: Int -> VkImagePipeSurfaceCreateFlagsFUCHSIA
zeroBits :: VkImagePipeSurfaceCreateFlagsFUCHSIA
$czeroBits :: VkImagePipeSurfaceCreateFlagsFUCHSIA
rotate :: VkImagePipeSurfaceCreateFlagsFUCHSIA
-> Int -> VkImagePipeSurfaceCreateFlagsFUCHSIA
$crotate :: VkImagePipeSurfaceCreateFlagsFUCHSIA
-> Int -> VkImagePipeSurfaceCreateFlagsFUCHSIA
shift :: VkImagePipeSurfaceCreateFlagsFUCHSIA
-> Int -> VkImagePipeSurfaceCreateFlagsFUCHSIA
$cshift :: VkImagePipeSurfaceCreateFlagsFUCHSIA
-> Int -> VkImagePipeSurfaceCreateFlagsFUCHSIA
complement :: VkImagePipeSurfaceCreateFlagsFUCHSIA
-> VkImagePipeSurfaceCreateFlagsFUCHSIA
$ccomplement :: VkImagePipeSurfaceCreateFlagsFUCHSIA
-> VkImagePipeSurfaceCreateFlagsFUCHSIA
xor :: VkImagePipeSurfaceCreateFlagsFUCHSIA
-> VkImagePipeSurfaceCreateFlagsFUCHSIA
-> VkImagePipeSurfaceCreateFlagsFUCHSIA
$cxor :: VkImagePipeSurfaceCreateFlagsFUCHSIA
-> VkImagePipeSurfaceCreateFlagsFUCHSIA
-> VkImagePipeSurfaceCreateFlagsFUCHSIA
.|. :: VkImagePipeSurfaceCreateFlagsFUCHSIA
-> VkImagePipeSurfaceCreateFlagsFUCHSIA
-> VkImagePipeSurfaceCreateFlagsFUCHSIA
$c.|. :: VkImagePipeSurfaceCreateFlagsFUCHSIA
-> VkImagePipeSurfaceCreateFlagsFUCHSIA
-> VkImagePipeSurfaceCreateFlagsFUCHSIA
.&. :: VkImagePipeSurfaceCreateFlagsFUCHSIA
-> VkImagePipeSurfaceCreateFlagsFUCHSIA
-> VkImagePipeSurfaceCreateFlagsFUCHSIA
$c.&. :: VkImagePipeSurfaceCreateFlagsFUCHSIA
-> VkImagePipeSurfaceCreateFlagsFUCHSIA
-> VkImagePipeSurfaceCreateFlagsFUCHSIA
Bits, Bits VkImagePipeSurfaceCreateFlagsFUCHSIA
Bits VkImagePipeSurfaceCreateFlagsFUCHSIA
-> (VkImagePipeSurfaceCreateFlagsFUCHSIA -> Int)
-> (VkImagePipeSurfaceCreateFlagsFUCHSIA -> Int)
-> (VkImagePipeSurfaceCreateFlagsFUCHSIA -> Int)
-> FiniteBits VkImagePipeSurfaceCreateFlagsFUCHSIA
VkImagePipeSurfaceCreateFlagsFUCHSIA -> Int
forall b.
Bits b -> (b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
countTrailingZeros :: VkImagePipeSurfaceCreateFlagsFUCHSIA -> Int
$ccountTrailingZeros :: VkImagePipeSurfaceCreateFlagsFUCHSIA -> Int
countLeadingZeros :: VkImagePipeSurfaceCreateFlagsFUCHSIA -> Int
$ccountLeadingZeros :: VkImagePipeSurfaceCreateFlagsFUCHSIA -> Int
finiteBitSize :: VkImagePipeSurfaceCreateFlagsFUCHSIA -> Int
$cfiniteBitSize :: VkImagePipeSurfaceCreateFlagsFUCHSIA -> Int
FiniteBits, Ptr VkImagePipeSurfaceCreateFlagsFUCHSIA
-> IO VkImagePipeSurfaceCreateFlagsFUCHSIA
Ptr VkImagePipeSurfaceCreateFlagsFUCHSIA
-> Int -> IO VkImagePipeSurfaceCreateFlagsFUCHSIA
Ptr VkImagePipeSurfaceCreateFlagsFUCHSIA
-> Int -> VkImagePipeSurfaceCreateFlagsFUCHSIA -> IO ()
Ptr VkImagePipeSurfaceCreateFlagsFUCHSIA
-> VkImagePipeSurfaceCreateFlagsFUCHSIA -> IO ()
VkImagePipeSurfaceCreateFlagsFUCHSIA -> Int
(VkImagePipeSurfaceCreateFlagsFUCHSIA -> Int)
-> (VkImagePipeSurfaceCreateFlagsFUCHSIA -> Int)
-> (Ptr VkImagePipeSurfaceCreateFlagsFUCHSIA
    -> Int -> IO VkImagePipeSurfaceCreateFlagsFUCHSIA)
-> (Ptr VkImagePipeSurfaceCreateFlagsFUCHSIA
    -> Int -> VkImagePipeSurfaceCreateFlagsFUCHSIA -> IO ())
-> (forall b.
    Ptr b -> Int -> IO VkImagePipeSurfaceCreateFlagsFUCHSIA)
-> (forall b.
    Ptr b -> Int -> VkImagePipeSurfaceCreateFlagsFUCHSIA -> IO ())
-> (Ptr VkImagePipeSurfaceCreateFlagsFUCHSIA
    -> IO VkImagePipeSurfaceCreateFlagsFUCHSIA)
-> (Ptr VkImagePipeSurfaceCreateFlagsFUCHSIA
    -> VkImagePipeSurfaceCreateFlagsFUCHSIA -> IO ())
-> Storable VkImagePipeSurfaceCreateFlagsFUCHSIA
forall b. Ptr b -> Int -> IO VkImagePipeSurfaceCreateFlagsFUCHSIA
forall b.
Ptr b -> Int -> VkImagePipeSurfaceCreateFlagsFUCHSIA -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr VkImagePipeSurfaceCreateFlagsFUCHSIA
-> VkImagePipeSurfaceCreateFlagsFUCHSIA -> IO ()
$cpoke :: Ptr VkImagePipeSurfaceCreateFlagsFUCHSIA
-> VkImagePipeSurfaceCreateFlagsFUCHSIA -> IO ()
peek :: Ptr VkImagePipeSurfaceCreateFlagsFUCHSIA
-> IO VkImagePipeSurfaceCreateFlagsFUCHSIA
$cpeek :: Ptr VkImagePipeSurfaceCreateFlagsFUCHSIA
-> IO VkImagePipeSurfaceCreateFlagsFUCHSIA
pokeByteOff :: forall b.
Ptr b -> Int -> VkImagePipeSurfaceCreateFlagsFUCHSIA -> IO ()
$cpokeByteOff :: forall b.
Ptr b -> Int -> VkImagePipeSurfaceCreateFlagsFUCHSIA -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO VkImagePipeSurfaceCreateFlagsFUCHSIA
$cpeekByteOff :: forall b. Ptr b -> Int -> IO VkImagePipeSurfaceCreateFlagsFUCHSIA
pokeElemOff :: Ptr VkImagePipeSurfaceCreateFlagsFUCHSIA
-> Int -> VkImagePipeSurfaceCreateFlagsFUCHSIA -> IO ()
$cpokeElemOff :: Ptr VkImagePipeSurfaceCreateFlagsFUCHSIA
-> Int -> VkImagePipeSurfaceCreateFlagsFUCHSIA -> IO ()
peekElemOff :: Ptr VkImagePipeSurfaceCreateFlagsFUCHSIA
-> Int -> IO VkImagePipeSurfaceCreateFlagsFUCHSIA
$cpeekElemOff :: Ptr VkImagePipeSurfaceCreateFlagsFUCHSIA
-> Int -> IO VkImagePipeSurfaceCreateFlagsFUCHSIA
alignment :: VkImagePipeSurfaceCreateFlagsFUCHSIA -> Int
$calignment :: VkImagePipeSurfaceCreateFlagsFUCHSIA -> Int
sizeOf :: VkImagePipeSurfaceCreateFlagsFUCHSIA -> Int
$csizeOf :: VkImagePipeSurfaceCreateFlagsFUCHSIA -> Int
Storable)

instance Show VkImagePipeSurfaceCreateFlagsFUCHSIA where
    {-# INLINE showsPrec #-}
    showsPrec :: Int -> VkImagePipeSurfaceCreateFlagsFUCHSIA -> ShowS
showsPrec = (Int -> VkFlags -> ShowS)
-> Int -> VkImagePipeSurfaceCreateFlagsFUCHSIA -> ShowS
coerce (Int -> VkFlags -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec :: Int -> VkFlags -> ShowS)

instance Read VkImagePipeSurfaceCreateFlagsFUCHSIA where
    {-# INLINE readsPrec #-}
    readsPrec :: Int -> ReadS VkImagePipeSurfaceCreateFlagsFUCHSIA
readsPrec = (Int -> ReadS VkFlags)
-> Int -> ReadS VkImagePipeSurfaceCreateFlagsFUCHSIA
coerce (Int -> ReadS VkFlags
forall a. Read a => Int -> ReadS a
readsPrec :: Int -> ReadS VkFlags)

newtype VkInstanceCreateFlags = VkInstanceCreateFlags VkFlags
                                deriving (VkInstanceCreateFlags -> VkInstanceCreateFlags -> Bool
(VkInstanceCreateFlags -> VkInstanceCreateFlags -> Bool)
-> (VkInstanceCreateFlags -> VkInstanceCreateFlags -> Bool)
-> Eq VkInstanceCreateFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VkInstanceCreateFlags -> VkInstanceCreateFlags -> Bool
$c/= :: VkInstanceCreateFlags -> VkInstanceCreateFlags -> Bool
== :: VkInstanceCreateFlags -> VkInstanceCreateFlags -> Bool
$c== :: VkInstanceCreateFlags -> VkInstanceCreateFlags -> Bool
Eq, Eq VkInstanceCreateFlags
Eq VkInstanceCreateFlags
-> (VkInstanceCreateFlags -> VkInstanceCreateFlags -> Ordering)
-> (VkInstanceCreateFlags -> VkInstanceCreateFlags -> Bool)
-> (VkInstanceCreateFlags -> VkInstanceCreateFlags -> Bool)
-> (VkInstanceCreateFlags -> VkInstanceCreateFlags -> Bool)
-> (VkInstanceCreateFlags -> VkInstanceCreateFlags -> Bool)
-> (VkInstanceCreateFlags
    -> VkInstanceCreateFlags -> VkInstanceCreateFlags)
-> (VkInstanceCreateFlags
    -> VkInstanceCreateFlags -> VkInstanceCreateFlags)
-> Ord VkInstanceCreateFlags
VkInstanceCreateFlags -> VkInstanceCreateFlags -> Bool
VkInstanceCreateFlags -> VkInstanceCreateFlags -> Ordering
VkInstanceCreateFlags
-> VkInstanceCreateFlags -> VkInstanceCreateFlags
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: VkInstanceCreateFlags
-> VkInstanceCreateFlags -> VkInstanceCreateFlags
$cmin :: VkInstanceCreateFlags
-> VkInstanceCreateFlags -> VkInstanceCreateFlags
max :: VkInstanceCreateFlags
-> VkInstanceCreateFlags -> VkInstanceCreateFlags
$cmax :: VkInstanceCreateFlags
-> VkInstanceCreateFlags -> VkInstanceCreateFlags
>= :: VkInstanceCreateFlags -> VkInstanceCreateFlags -> Bool
$c>= :: VkInstanceCreateFlags -> VkInstanceCreateFlags -> Bool
> :: VkInstanceCreateFlags -> VkInstanceCreateFlags -> Bool
$c> :: VkInstanceCreateFlags -> VkInstanceCreateFlags -> Bool
<= :: VkInstanceCreateFlags -> VkInstanceCreateFlags -> Bool
$c<= :: VkInstanceCreateFlags -> VkInstanceCreateFlags -> Bool
< :: VkInstanceCreateFlags -> VkInstanceCreateFlags -> Bool
$c< :: VkInstanceCreateFlags -> VkInstanceCreateFlags -> Bool
compare :: VkInstanceCreateFlags -> VkInstanceCreateFlags -> Ordering
$ccompare :: VkInstanceCreateFlags -> VkInstanceCreateFlags -> Ordering
Ord, Int -> VkInstanceCreateFlags
VkInstanceCreateFlags -> Int
VkInstanceCreateFlags -> [VkInstanceCreateFlags]
VkInstanceCreateFlags -> VkInstanceCreateFlags
VkInstanceCreateFlags
-> VkInstanceCreateFlags -> [VkInstanceCreateFlags]
VkInstanceCreateFlags
-> VkInstanceCreateFlags
-> VkInstanceCreateFlags
-> [VkInstanceCreateFlags]
(VkInstanceCreateFlags -> VkInstanceCreateFlags)
-> (VkInstanceCreateFlags -> VkInstanceCreateFlags)
-> (Int -> VkInstanceCreateFlags)
-> (VkInstanceCreateFlags -> Int)
-> (VkInstanceCreateFlags -> [VkInstanceCreateFlags])
-> (VkInstanceCreateFlags
    -> VkInstanceCreateFlags -> [VkInstanceCreateFlags])
-> (VkInstanceCreateFlags
    -> VkInstanceCreateFlags -> [VkInstanceCreateFlags])
-> (VkInstanceCreateFlags
    -> VkInstanceCreateFlags
    -> VkInstanceCreateFlags
    -> [VkInstanceCreateFlags])
-> Enum VkInstanceCreateFlags
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: VkInstanceCreateFlags
-> VkInstanceCreateFlags
-> VkInstanceCreateFlags
-> [VkInstanceCreateFlags]
$cenumFromThenTo :: VkInstanceCreateFlags
-> VkInstanceCreateFlags
-> VkInstanceCreateFlags
-> [VkInstanceCreateFlags]
enumFromTo :: VkInstanceCreateFlags
-> VkInstanceCreateFlags -> [VkInstanceCreateFlags]
$cenumFromTo :: VkInstanceCreateFlags
-> VkInstanceCreateFlags -> [VkInstanceCreateFlags]
enumFromThen :: VkInstanceCreateFlags
-> VkInstanceCreateFlags -> [VkInstanceCreateFlags]
$cenumFromThen :: VkInstanceCreateFlags
-> VkInstanceCreateFlags -> [VkInstanceCreateFlags]
enumFrom :: VkInstanceCreateFlags -> [VkInstanceCreateFlags]
$cenumFrom :: VkInstanceCreateFlags -> [VkInstanceCreateFlags]
fromEnum :: VkInstanceCreateFlags -> Int
$cfromEnum :: VkInstanceCreateFlags -> Int
toEnum :: Int -> VkInstanceCreateFlags
$ctoEnum :: Int -> VkInstanceCreateFlags
pred :: VkInstanceCreateFlags -> VkInstanceCreateFlags
$cpred :: VkInstanceCreateFlags -> VkInstanceCreateFlags
succ :: VkInstanceCreateFlags -> VkInstanceCreateFlags
$csucc :: VkInstanceCreateFlags -> VkInstanceCreateFlags
Enum, Eq VkInstanceCreateFlags
VkInstanceCreateFlags
Eq VkInstanceCreateFlags
-> (VkInstanceCreateFlags
    -> VkInstanceCreateFlags -> VkInstanceCreateFlags)
-> (VkInstanceCreateFlags
    -> VkInstanceCreateFlags -> VkInstanceCreateFlags)
-> (VkInstanceCreateFlags
    -> VkInstanceCreateFlags -> VkInstanceCreateFlags)
-> (VkInstanceCreateFlags -> VkInstanceCreateFlags)
-> (VkInstanceCreateFlags -> Int -> VkInstanceCreateFlags)
-> (VkInstanceCreateFlags -> Int -> VkInstanceCreateFlags)
-> VkInstanceCreateFlags
-> (Int -> VkInstanceCreateFlags)
-> (VkInstanceCreateFlags -> Int -> VkInstanceCreateFlags)
-> (VkInstanceCreateFlags -> Int -> VkInstanceCreateFlags)
-> (VkInstanceCreateFlags -> Int -> VkInstanceCreateFlags)
-> (VkInstanceCreateFlags -> Int -> Bool)
-> (VkInstanceCreateFlags -> Maybe Int)
-> (VkInstanceCreateFlags -> Int)
-> (VkInstanceCreateFlags -> Bool)
-> (VkInstanceCreateFlags -> Int -> VkInstanceCreateFlags)
-> (VkInstanceCreateFlags -> Int -> VkInstanceCreateFlags)
-> (VkInstanceCreateFlags -> Int -> VkInstanceCreateFlags)
-> (VkInstanceCreateFlags -> Int -> VkInstanceCreateFlags)
-> (VkInstanceCreateFlags -> Int -> VkInstanceCreateFlags)
-> (VkInstanceCreateFlags -> Int -> VkInstanceCreateFlags)
-> (VkInstanceCreateFlags -> Int)
-> Bits VkInstanceCreateFlags
Int -> VkInstanceCreateFlags
VkInstanceCreateFlags -> Bool
VkInstanceCreateFlags -> Int
VkInstanceCreateFlags -> Maybe Int
VkInstanceCreateFlags -> VkInstanceCreateFlags
VkInstanceCreateFlags -> Int -> Bool
VkInstanceCreateFlags -> Int -> VkInstanceCreateFlags
VkInstanceCreateFlags
-> VkInstanceCreateFlags -> VkInstanceCreateFlags
forall a.
Eq a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
popCount :: VkInstanceCreateFlags -> Int
$cpopCount :: VkInstanceCreateFlags -> Int
rotateR :: VkInstanceCreateFlags -> Int -> VkInstanceCreateFlags
$crotateR :: VkInstanceCreateFlags -> Int -> VkInstanceCreateFlags
rotateL :: VkInstanceCreateFlags -> Int -> VkInstanceCreateFlags
$crotateL :: VkInstanceCreateFlags -> Int -> VkInstanceCreateFlags
unsafeShiftR :: VkInstanceCreateFlags -> Int -> VkInstanceCreateFlags
$cunsafeShiftR :: VkInstanceCreateFlags -> Int -> VkInstanceCreateFlags
shiftR :: VkInstanceCreateFlags -> Int -> VkInstanceCreateFlags
$cshiftR :: VkInstanceCreateFlags -> Int -> VkInstanceCreateFlags
unsafeShiftL :: VkInstanceCreateFlags -> Int -> VkInstanceCreateFlags
$cunsafeShiftL :: VkInstanceCreateFlags -> Int -> VkInstanceCreateFlags
shiftL :: VkInstanceCreateFlags -> Int -> VkInstanceCreateFlags
$cshiftL :: VkInstanceCreateFlags -> Int -> VkInstanceCreateFlags
isSigned :: VkInstanceCreateFlags -> Bool
$cisSigned :: VkInstanceCreateFlags -> Bool
bitSize :: VkInstanceCreateFlags -> Int
$cbitSize :: VkInstanceCreateFlags -> Int
bitSizeMaybe :: VkInstanceCreateFlags -> Maybe Int
$cbitSizeMaybe :: VkInstanceCreateFlags -> Maybe Int
testBit :: VkInstanceCreateFlags -> Int -> Bool
$ctestBit :: VkInstanceCreateFlags -> Int -> Bool
complementBit :: VkInstanceCreateFlags -> Int -> VkInstanceCreateFlags
$ccomplementBit :: VkInstanceCreateFlags -> Int -> VkInstanceCreateFlags
clearBit :: VkInstanceCreateFlags -> Int -> VkInstanceCreateFlags
$cclearBit :: VkInstanceCreateFlags -> Int -> VkInstanceCreateFlags
setBit :: VkInstanceCreateFlags -> Int -> VkInstanceCreateFlags
$csetBit :: VkInstanceCreateFlags -> Int -> VkInstanceCreateFlags
bit :: Int -> VkInstanceCreateFlags
$cbit :: Int -> VkInstanceCreateFlags
zeroBits :: VkInstanceCreateFlags
$czeroBits :: VkInstanceCreateFlags
rotate :: VkInstanceCreateFlags -> Int -> VkInstanceCreateFlags
$crotate :: VkInstanceCreateFlags -> Int -> VkInstanceCreateFlags
shift :: VkInstanceCreateFlags -> Int -> VkInstanceCreateFlags
$cshift :: VkInstanceCreateFlags -> Int -> VkInstanceCreateFlags
complement :: VkInstanceCreateFlags -> VkInstanceCreateFlags
$ccomplement :: VkInstanceCreateFlags -> VkInstanceCreateFlags
xor :: VkInstanceCreateFlags
-> VkInstanceCreateFlags -> VkInstanceCreateFlags
$cxor :: VkInstanceCreateFlags
-> VkInstanceCreateFlags -> VkInstanceCreateFlags
.|. :: VkInstanceCreateFlags
-> VkInstanceCreateFlags -> VkInstanceCreateFlags
$c.|. :: VkInstanceCreateFlags
-> VkInstanceCreateFlags -> VkInstanceCreateFlags
.&. :: VkInstanceCreateFlags
-> VkInstanceCreateFlags -> VkInstanceCreateFlags
$c.&. :: VkInstanceCreateFlags
-> VkInstanceCreateFlags -> VkInstanceCreateFlags
Bits, Bits VkInstanceCreateFlags
Bits VkInstanceCreateFlags
-> (VkInstanceCreateFlags -> Int)
-> (VkInstanceCreateFlags -> Int)
-> (VkInstanceCreateFlags -> Int)
-> FiniteBits VkInstanceCreateFlags
VkInstanceCreateFlags -> Int
forall b.
Bits b -> (b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
countTrailingZeros :: VkInstanceCreateFlags -> Int
$ccountTrailingZeros :: VkInstanceCreateFlags -> Int
countLeadingZeros :: VkInstanceCreateFlags -> Int
$ccountLeadingZeros :: VkInstanceCreateFlags -> Int
finiteBitSize :: VkInstanceCreateFlags -> Int
$cfiniteBitSize :: VkInstanceCreateFlags -> Int
FiniteBits, Ptr VkInstanceCreateFlags -> IO VkInstanceCreateFlags
Ptr VkInstanceCreateFlags -> Int -> IO VkInstanceCreateFlags
Ptr VkInstanceCreateFlags -> Int -> VkInstanceCreateFlags -> IO ()
Ptr VkInstanceCreateFlags -> VkInstanceCreateFlags -> IO ()
VkInstanceCreateFlags -> Int
(VkInstanceCreateFlags -> Int)
-> (VkInstanceCreateFlags -> Int)
-> (Ptr VkInstanceCreateFlags -> Int -> IO VkInstanceCreateFlags)
-> (Ptr VkInstanceCreateFlags
    -> Int -> VkInstanceCreateFlags -> IO ())
-> (forall b. Ptr b -> Int -> IO VkInstanceCreateFlags)
-> (forall b. Ptr b -> Int -> VkInstanceCreateFlags -> IO ())
-> (Ptr VkInstanceCreateFlags -> IO VkInstanceCreateFlags)
-> (Ptr VkInstanceCreateFlags -> VkInstanceCreateFlags -> IO ())
-> Storable VkInstanceCreateFlags
forall b. Ptr b -> Int -> IO VkInstanceCreateFlags
forall b. Ptr b -> Int -> VkInstanceCreateFlags -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr VkInstanceCreateFlags -> VkInstanceCreateFlags -> IO ()
$cpoke :: Ptr VkInstanceCreateFlags -> VkInstanceCreateFlags -> IO ()
peek :: Ptr VkInstanceCreateFlags -> IO VkInstanceCreateFlags
$cpeek :: Ptr VkInstanceCreateFlags -> IO VkInstanceCreateFlags
pokeByteOff :: forall b. Ptr b -> Int -> VkInstanceCreateFlags -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> VkInstanceCreateFlags -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO VkInstanceCreateFlags
$cpeekByteOff :: forall b. Ptr b -> Int -> IO VkInstanceCreateFlags
pokeElemOff :: Ptr VkInstanceCreateFlags -> Int -> VkInstanceCreateFlags -> IO ()
$cpokeElemOff :: Ptr VkInstanceCreateFlags -> Int -> VkInstanceCreateFlags -> IO ()
peekElemOff :: Ptr VkInstanceCreateFlags -> Int -> IO VkInstanceCreateFlags
$cpeekElemOff :: Ptr VkInstanceCreateFlags -> Int -> IO VkInstanceCreateFlags
alignment :: VkInstanceCreateFlags -> Int
$calignment :: VkInstanceCreateFlags -> Int
sizeOf :: VkInstanceCreateFlags -> Int
$csizeOf :: VkInstanceCreateFlags -> Int
Storable)

instance Show VkInstanceCreateFlags where
    {-# INLINE showsPrec #-}
    showsPrec :: Int -> VkInstanceCreateFlags -> ShowS
showsPrec = (Int -> VkFlags -> ShowS) -> Int -> VkInstanceCreateFlags -> ShowS
coerce (Int -> VkFlags -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec :: Int -> VkFlags -> ShowS)

instance Read VkInstanceCreateFlags where
    {-# INLINE readsPrec #-}
    readsPrec :: Int -> ReadS VkInstanceCreateFlags
readsPrec = (Int -> ReadS VkFlags) -> Int -> ReadS VkInstanceCreateFlags
coerce (Int -> ReadS VkFlags
forall a. Read a => Int -> ReadS a
readsPrec :: Int -> ReadS VkFlags)

newtype VkMacOSSurfaceCreateFlagsMVK = VkMacOSSurfaceCreateFlagsMVK VkFlags
                                       deriving (VkMacOSSurfaceCreateFlagsMVK
-> VkMacOSSurfaceCreateFlagsMVK -> Bool
(VkMacOSSurfaceCreateFlagsMVK
 -> VkMacOSSurfaceCreateFlagsMVK -> Bool)
-> (VkMacOSSurfaceCreateFlagsMVK
    -> VkMacOSSurfaceCreateFlagsMVK -> Bool)
-> Eq VkMacOSSurfaceCreateFlagsMVK
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VkMacOSSurfaceCreateFlagsMVK
-> VkMacOSSurfaceCreateFlagsMVK -> Bool
$c/= :: VkMacOSSurfaceCreateFlagsMVK
-> VkMacOSSurfaceCreateFlagsMVK -> Bool
== :: VkMacOSSurfaceCreateFlagsMVK
-> VkMacOSSurfaceCreateFlagsMVK -> Bool
$c== :: VkMacOSSurfaceCreateFlagsMVK
-> VkMacOSSurfaceCreateFlagsMVK -> Bool
Eq, Eq VkMacOSSurfaceCreateFlagsMVK
Eq VkMacOSSurfaceCreateFlagsMVK
-> (VkMacOSSurfaceCreateFlagsMVK
    -> VkMacOSSurfaceCreateFlagsMVK -> Ordering)
-> (VkMacOSSurfaceCreateFlagsMVK
    -> VkMacOSSurfaceCreateFlagsMVK -> Bool)
-> (VkMacOSSurfaceCreateFlagsMVK
    -> VkMacOSSurfaceCreateFlagsMVK -> Bool)
-> (VkMacOSSurfaceCreateFlagsMVK
    -> VkMacOSSurfaceCreateFlagsMVK -> Bool)
-> (VkMacOSSurfaceCreateFlagsMVK
    -> VkMacOSSurfaceCreateFlagsMVK -> Bool)
-> (VkMacOSSurfaceCreateFlagsMVK
    -> VkMacOSSurfaceCreateFlagsMVK -> VkMacOSSurfaceCreateFlagsMVK)
-> (VkMacOSSurfaceCreateFlagsMVK
    -> VkMacOSSurfaceCreateFlagsMVK -> VkMacOSSurfaceCreateFlagsMVK)
-> Ord VkMacOSSurfaceCreateFlagsMVK
VkMacOSSurfaceCreateFlagsMVK
-> VkMacOSSurfaceCreateFlagsMVK -> Bool
VkMacOSSurfaceCreateFlagsMVK
-> VkMacOSSurfaceCreateFlagsMVK -> Ordering
VkMacOSSurfaceCreateFlagsMVK
-> VkMacOSSurfaceCreateFlagsMVK -> VkMacOSSurfaceCreateFlagsMVK
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: VkMacOSSurfaceCreateFlagsMVK
-> VkMacOSSurfaceCreateFlagsMVK -> VkMacOSSurfaceCreateFlagsMVK
$cmin :: VkMacOSSurfaceCreateFlagsMVK
-> VkMacOSSurfaceCreateFlagsMVK -> VkMacOSSurfaceCreateFlagsMVK
max :: VkMacOSSurfaceCreateFlagsMVK
-> VkMacOSSurfaceCreateFlagsMVK -> VkMacOSSurfaceCreateFlagsMVK
$cmax :: VkMacOSSurfaceCreateFlagsMVK
-> VkMacOSSurfaceCreateFlagsMVK -> VkMacOSSurfaceCreateFlagsMVK
>= :: VkMacOSSurfaceCreateFlagsMVK
-> VkMacOSSurfaceCreateFlagsMVK -> Bool
$c>= :: VkMacOSSurfaceCreateFlagsMVK
-> VkMacOSSurfaceCreateFlagsMVK -> Bool
> :: VkMacOSSurfaceCreateFlagsMVK
-> VkMacOSSurfaceCreateFlagsMVK -> Bool
$c> :: VkMacOSSurfaceCreateFlagsMVK
-> VkMacOSSurfaceCreateFlagsMVK -> Bool
<= :: VkMacOSSurfaceCreateFlagsMVK
-> VkMacOSSurfaceCreateFlagsMVK -> Bool
$c<= :: VkMacOSSurfaceCreateFlagsMVK
-> VkMacOSSurfaceCreateFlagsMVK -> Bool
< :: VkMacOSSurfaceCreateFlagsMVK
-> VkMacOSSurfaceCreateFlagsMVK -> Bool
$c< :: VkMacOSSurfaceCreateFlagsMVK
-> VkMacOSSurfaceCreateFlagsMVK -> Bool
compare :: VkMacOSSurfaceCreateFlagsMVK
-> VkMacOSSurfaceCreateFlagsMVK -> Ordering
$ccompare :: VkMacOSSurfaceCreateFlagsMVK
-> VkMacOSSurfaceCreateFlagsMVK -> Ordering
Ord, Int -> VkMacOSSurfaceCreateFlagsMVK
VkMacOSSurfaceCreateFlagsMVK -> Int
VkMacOSSurfaceCreateFlagsMVK -> [VkMacOSSurfaceCreateFlagsMVK]
VkMacOSSurfaceCreateFlagsMVK -> VkMacOSSurfaceCreateFlagsMVK
VkMacOSSurfaceCreateFlagsMVK
-> VkMacOSSurfaceCreateFlagsMVK -> [VkMacOSSurfaceCreateFlagsMVK]
VkMacOSSurfaceCreateFlagsMVK
-> VkMacOSSurfaceCreateFlagsMVK
-> VkMacOSSurfaceCreateFlagsMVK
-> [VkMacOSSurfaceCreateFlagsMVK]
(VkMacOSSurfaceCreateFlagsMVK -> VkMacOSSurfaceCreateFlagsMVK)
-> (VkMacOSSurfaceCreateFlagsMVK -> VkMacOSSurfaceCreateFlagsMVK)
-> (Int -> VkMacOSSurfaceCreateFlagsMVK)
-> (VkMacOSSurfaceCreateFlagsMVK -> Int)
-> (VkMacOSSurfaceCreateFlagsMVK -> [VkMacOSSurfaceCreateFlagsMVK])
-> (VkMacOSSurfaceCreateFlagsMVK
    -> VkMacOSSurfaceCreateFlagsMVK -> [VkMacOSSurfaceCreateFlagsMVK])
-> (VkMacOSSurfaceCreateFlagsMVK
    -> VkMacOSSurfaceCreateFlagsMVK -> [VkMacOSSurfaceCreateFlagsMVK])
-> (VkMacOSSurfaceCreateFlagsMVK
    -> VkMacOSSurfaceCreateFlagsMVK
    -> VkMacOSSurfaceCreateFlagsMVK
    -> [VkMacOSSurfaceCreateFlagsMVK])
-> Enum VkMacOSSurfaceCreateFlagsMVK
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: VkMacOSSurfaceCreateFlagsMVK
-> VkMacOSSurfaceCreateFlagsMVK
-> VkMacOSSurfaceCreateFlagsMVK
-> [VkMacOSSurfaceCreateFlagsMVK]
$cenumFromThenTo :: VkMacOSSurfaceCreateFlagsMVK
-> VkMacOSSurfaceCreateFlagsMVK
-> VkMacOSSurfaceCreateFlagsMVK
-> [VkMacOSSurfaceCreateFlagsMVK]
enumFromTo :: VkMacOSSurfaceCreateFlagsMVK
-> VkMacOSSurfaceCreateFlagsMVK -> [VkMacOSSurfaceCreateFlagsMVK]
$cenumFromTo :: VkMacOSSurfaceCreateFlagsMVK
-> VkMacOSSurfaceCreateFlagsMVK -> [VkMacOSSurfaceCreateFlagsMVK]
enumFromThen :: VkMacOSSurfaceCreateFlagsMVK
-> VkMacOSSurfaceCreateFlagsMVK -> [VkMacOSSurfaceCreateFlagsMVK]
$cenumFromThen :: VkMacOSSurfaceCreateFlagsMVK
-> VkMacOSSurfaceCreateFlagsMVK -> [VkMacOSSurfaceCreateFlagsMVK]
enumFrom :: VkMacOSSurfaceCreateFlagsMVK -> [VkMacOSSurfaceCreateFlagsMVK]
$cenumFrom :: VkMacOSSurfaceCreateFlagsMVK -> [VkMacOSSurfaceCreateFlagsMVK]
fromEnum :: VkMacOSSurfaceCreateFlagsMVK -> Int
$cfromEnum :: VkMacOSSurfaceCreateFlagsMVK -> Int
toEnum :: Int -> VkMacOSSurfaceCreateFlagsMVK
$ctoEnum :: Int -> VkMacOSSurfaceCreateFlagsMVK
pred :: VkMacOSSurfaceCreateFlagsMVK -> VkMacOSSurfaceCreateFlagsMVK
$cpred :: VkMacOSSurfaceCreateFlagsMVK -> VkMacOSSurfaceCreateFlagsMVK
succ :: VkMacOSSurfaceCreateFlagsMVK -> VkMacOSSurfaceCreateFlagsMVK
$csucc :: VkMacOSSurfaceCreateFlagsMVK -> VkMacOSSurfaceCreateFlagsMVK
Enum, Eq VkMacOSSurfaceCreateFlagsMVK
VkMacOSSurfaceCreateFlagsMVK
Eq VkMacOSSurfaceCreateFlagsMVK
-> (VkMacOSSurfaceCreateFlagsMVK
    -> VkMacOSSurfaceCreateFlagsMVK -> VkMacOSSurfaceCreateFlagsMVK)
-> (VkMacOSSurfaceCreateFlagsMVK
    -> VkMacOSSurfaceCreateFlagsMVK -> VkMacOSSurfaceCreateFlagsMVK)
-> (VkMacOSSurfaceCreateFlagsMVK
    -> VkMacOSSurfaceCreateFlagsMVK -> VkMacOSSurfaceCreateFlagsMVK)
-> (VkMacOSSurfaceCreateFlagsMVK -> VkMacOSSurfaceCreateFlagsMVK)
-> (VkMacOSSurfaceCreateFlagsMVK
    -> Int -> VkMacOSSurfaceCreateFlagsMVK)
-> (VkMacOSSurfaceCreateFlagsMVK
    -> Int -> VkMacOSSurfaceCreateFlagsMVK)
-> VkMacOSSurfaceCreateFlagsMVK
-> (Int -> VkMacOSSurfaceCreateFlagsMVK)
-> (VkMacOSSurfaceCreateFlagsMVK
    -> Int -> VkMacOSSurfaceCreateFlagsMVK)
-> (VkMacOSSurfaceCreateFlagsMVK
    -> Int -> VkMacOSSurfaceCreateFlagsMVK)
-> (VkMacOSSurfaceCreateFlagsMVK
    -> Int -> VkMacOSSurfaceCreateFlagsMVK)
-> (VkMacOSSurfaceCreateFlagsMVK -> Int -> Bool)
-> (VkMacOSSurfaceCreateFlagsMVK -> Maybe Int)
-> (VkMacOSSurfaceCreateFlagsMVK -> Int)
-> (VkMacOSSurfaceCreateFlagsMVK -> Bool)
-> (VkMacOSSurfaceCreateFlagsMVK
    -> Int -> VkMacOSSurfaceCreateFlagsMVK)
-> (VkMacOSSurfaceCreateFlagsMVK
    -> Int -> VkMacOSSurfaceCreateFlagsMVK)
-> (VkMacOSSurfaceCreateFlagsMVK
    -> Int -> VkMacOSSurfaceCreateFlagsMVK)
-> (VkMacOSSurfaceCreateFlagsMVK
    -> Int -> VkMacOSSurfaceCreateFlagsMVK)
-> (VkMacOSSurfaceCreateFlagsMVK
    -> Int -> VkMacOSSurfaceCreateFlagsMVK)
-> (VkMacOSSurfaceCreateFlagsMVK
    -> Int -> VkMacOSSurfaceCreateFlagsMVK)
-> (VkMacOSSurfaceCreateFlagsMVK -> Int)
-> Bits VkMacOSSurfaceCreateFlagsMVK
Int -> VkMacOSSurfaceCreateFlagsMVK
VkMacOSSurfaceCreateFlagsMVK -> Bool
VkMacOSSurfaceCreateFlagsMVK -> Int
VkMacOSSurfaceCreateFlagsMVK -> Maybe Int
VkMacOSSurfaceCreateFlagsMVK -> VkMacOSSurfaceCreateFlagsMVK
VkMacOSSurfaceCreateFlagsMVK -> Int -> Bool
VkMacOSSurfaceCreateFlagsMVK -> Int -> VkMacOSSurfaceCreateFlagsMVK
VkMacOSSurfaceCreateFlagsMVK
-> VkMacOSSurfaceCreateFlagsMVK -> VkMacOSSurfaceCreateFlagsMVK
forall a.
Eq a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
popCount :: VkMacOSSurfaceCreateFlagsMVK -> Int
$cpopCount :: VkMacOSSurfaceCreateFlagsMVK -> Int
rotateR :: VkMacOSSurfaceCreateFlagsMVK -> Int -> VkMacOSSurfaceCreateFlagsMVK
$crotateR :: VkMacOSSurfaceCreateFlagsMVK -> Int -> VkMacOSSurfaceCreateFlagsMVK
rotateL :: VkMacOSSurfaceCreateFlagsMVK -> Int -> VkMacOSSurfaceCreateFlagsMVK
$crotateL :: VkMacOSSurfaceCreateFlagsMVK -> Int -> VkMacOSSurfaceCreateFlagsMVK
unsafeShiftR :: VkMacOSSurfaceCreateFlagsMVK -> Int -> VkMacOSSurfaceCreateFlagsMVK
$cunsafeShiftR :: VkMacOSSurfaceCreateFlagsMVK -> Int -> VkMacOSSurfaceCreateFlagsMVK
shiftR :: VkMacOSSurfaceCreateFlagsMVK -> Int -> VkMacOSSurfaceCreateFlagsMVK
$cshiftR :: VkMacOSSurfaceCreateFlagsMVK -> Int -> VkMacOSSurfaceCreateFlagsMVK
unsafeShiftL :: VkMacOSSurfaceCreateFlagsMVK -> Int -> VkMacOSSurfaceCreateFlagsMVK
$cunsafeShiftL :: VkMacOSSurfaceCreateFlagsMVK -> Int -> VkMacOSSurfaceCreateFlagsMVK
shiftL :: VkMacOSSurfaceCreateFlagsMVK -> Int -> VkMacOSSurfaceCreateFlagsMVK
$cshiftL :: VkMacOSSurfaceCreateFlagsMVK -> Int -> VkMacOSSurfaceCreateFlagsMVK
isSigned :: VkMacOSSurfaceCreateFlagsMVK -> Bool
$cisSigned :: VkMacOSSurfaceCreateFlagsMVK -> Bool
bitSize :: VkMacOSSurfaceCreateFlagsMVK -> Int
$cbitSize :: VkMacOSSurfaceCreateFlagsMVK -> Int
bitSizeMaybe :: VkMacOSSurfaceCreateFlagsMVK -> Maybe Int
$cbitSizeMaybe :: VkMacOSSurfaceCreateFlagsMVK -> Maybe Int
testBit :: VkMacOSSurfaceCreateFlagsMVK -> Int -> Bool
$ctestBit :: VkMacOSSurfaceCreateFlagsMVK -> Int -> Bool
complementBit :: VkMacOSSurfaceCreateFlagsMVK -> Int -> VkMacOSSurfaceCreateFlagsMVK
$ccomplementBit :: VkMacOSSurfaceCreateFlagsMVK -> Int -> VkMacOSSurfaceCreateFlagsMVK
clearBit :: VkMacOSSurfaceCreateFlagsMVK -> Int -> VkMacOSSurfaceCreateFlagsMVK
$cclearBit :: VkMacOSSurfaceCreateFlagsMVK -> Int -> VkMacOSSurfaceCreateFlagsMVK
setBit :: VkMacOSSurfaceCreateFlagsMVK -> Int -> VkMacOSSurfaceCreateFlagsMVK
$csetBit :: VkMacOSSurfaceCreateFlagsMVK -> Int -> VkMacOSSurfaceCreateFlagsMVK
bit :: Int -> VkMacOSSurfaceCreateFlagsMVK
$cbit :: Int -> VkMacOSSurfaceCreateFlagsMVK
zeroBits :: VkMacOSSurfaceCreateFlagsMVK
$czeroBits :: VkMacOSSurfaceCreateFlagsMVK
rotate :: VkMacOSSurfaceCreateFlagsMVK -> Int -> VkMacOSSurfaceCreateFlagsMVK
$crotate :: VkMacOSSurfaceCreateFlagsMVK -> Int -> VkMacOSSurfaceCreateFlagsMVK
shift :: VkMacOSSurfaceCreateFlagsMVK -> Int -> VkMacOSSurfaceCreateFlagsMVK
$cshift :: VkMacOSSurfaceCreateFlagsMVK -> Int -> VkMacOSSurfaceCreateFlagsMVK
complement :: VkMacOSSurfaceCreateFlagsMVK -> VkMacOSSurfaceCreateFlagsMVK
$ccomplement :: VkMacOSSurfaceCreateFlagsMVK -> VkMacOSSurfaceCreateFlagsMVK
xor :: VkMacOSSurfaceCreateFlagsMVK
-> VkMacOSSurfaceCreateFlagsMVK -> VkMacOSSurfaceCreateFlagsMVK
$cxor :: VkMacOSSurfaceCreateFlagsMVK
-> VkMacOSSurfaceCreateFlagsMVK -> VkMacOSSurfaceCreateFlagsMVK
.|. :: VkMacOSSurfaceCreateFlagsMVK
-> VkMacOSSurfaceCreateFlagsMVK -> VkMacOSSurfaceCreateFlagsMVK
$c.|. :: VkMacOSSurfaceCreateFlagsMVK
-> VkMacOSSurfaceCreateFlagsMVK -> VkMacOSSurfaceCreateFlagsMVK
.&. :: VkMacOSSurfaceCreateFlagsMVK
-> VkMacOSSurfaceCreateFlagsMVK -> VkMacOSSurfaceCreateFlagsMVK
$c.&. :: VkMacOSSurfaceCreateFlagsMVK
-> VkMacOSSurfaceCreateFlagsMVK -> VkMacOSSurfaceCreateFlagsMVK
Bits, Bits VkMacOSSurfaceCreateFlagsMVK
Bits VkMacOSSurfaceCreateFlagsMVK
-> (VkMacOSSurfaceCreateFlagsMVK -> Int)
-> (VkMacOSSurfaceCreateFlagsMVK -> Int)
-> (VkMacOSSurfaceCreateFlagsMVK -> Int)
-> FiniteBits VkMacOSSurfaceCreateFlagsMVK
VkMacOSSurfaceCreateFlagsMVK -> Int
forall b.
Bits b -> (b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
countTrailingZeros :: VkMacOSSurfaceCreateFlagsMVK -> Int
$ccountTrailingZeros :: VkMacOSSurfaceCreateFlagsMVK -> Int
countLeadingZeros :: VkMacOSSurfaceCreateFlagsMVK -> Int
$ccountLeadingZeros :: VkMacOSSurfaceCreateFlagsMVK -> Int
finiteBitSize :: VkMacOSSurfaceCreateFlagsMVK -> Int
$cfiniteBitSize :: VkMacOSSurfaceCreateFlagsMVK -> Int
FiniteBits, Ptr VkMacOSSurfaceCreateFlagsMVK -> IO VkMacOSSurfaceCreateFlagsMVK
Ptr VkMacOSSurfaceCreateFlagsMVK
-> Int -> IO VkMacOSSurfaceCreateFlagsMVK
Ptr VkMacOSSurfaceCreateFlagsMVK
-> Int -> VkMacOSSurfaceCreateFlagsMVK -> IO ()
Ptr VkMacOSSurfaceCreateFlagsMVK
-> VkMacOSSurfaceCreateFlagsMVK -> IO ()
VkMacOSSurfaceCreateFlagsMVK -> Int
(VkMacOSSurfaceCreateFlagsMVK -> Int)
-> (VkMacOSSurfaceCreateFlagsMVK -> Int)
-> (Ptr VkMacOSSurfaceCreateFlagsMVK
    -> Int -> IO VkMacOSSurfaceCreateFlagsMVK)
-> (Ptr VkMacOSSurfaceCreateFlagsMVK
    -> Int -> VkMacOSSurfaceCreateFlagsMVK -> IO ())
-> (forall b. Ptr b -> Int -> IO VkMacOSSurfaceCreateFlagsMVK)
-> (forall b.
    Ptr b -> Int -> VkMacOSSurfaceCreateFlagsMVK -> IO ())
-> (Ptr VkMacOSSurfaceCreateFlagsMVK
    -> IO VkMacOSSurfaceCreateFlagsMVK)
-> (Ptr VkMacOSSurfaceCreateFlagsMVK
    -> VkMacOSSurfaceCreateFlagsMVK -> IO ())
-> Storable VkMacOSSurfaceCreateFlagsMVK
forall b. Ptr b -> Int -> IO VkMacOSSurfaceCreateFlagsMVK
forall b. Ptr b -> Int -> VkMacOSSurfaceCreateFlagsMVK -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr VkMacOSSurfaceCreateFlagsMVK
-> VkMacOSSurfaceCreateFlagsMVK -> IO ()
$cpoke :: Ptr VkMacOSSurfaceCreateFlagsMVK
-> VkMacOSSurfaceCreateFlagsMVK -> IO ()
peek :: Ptr VkMacOSSurfaceCreateFlagsMVK -> IO VkMacOSSurfaceCreateFlagsMVK
$cpeek :: Ptr VkMacOSSurfaceCreateFlagsMVK -> IO VkMacOSSurfaceCreateFlagsMVK
pokeByteOff :: forall b. Ptr b -> Int -> VkMacOSSurfaceCreateFlagsMVK -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> VkMacOSSurfaceCreateFlagsMVK -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO VkMacOSSurfaceCreateFlagsMVK
$cpeekByteOff :: forall b. Ptr b -> Int -> IO VkMacOSSurfaceCreateFlagsMVK
pokeElemOff :: Ptr VkMacOSSurfaceCreateFlagsMVK
-> Int -> VkMacOSSurfaceCreateFlagsMVK -> IO ()
$cpokeElemOff :: Ptr VkMacOSSurfaceCreateFlagsMVK
-> Int -> VkMacOSSurfaceCreateFlagsMVK -> IO ()
peekElemOff :: Ptr VkMacOSSurfaceCreateFlagsMVK
-> Int -> IO VkMacOSSurfaceCreateFlagsMVK
$cpeekElemOff :: Ptr VkMacOSSurfaceCreateFlagsMVK
-> Int -> IO VkMacOSSurfaceCreateFlagsMVK
alignment :: VkMacOSSurfaceCreateFlagsMVK -> Int
$calignment :: VkMacOSSurfaceCreateFlagsMVK -> Int
sizeOf :: VkMacOSSurfaceCreateFlagsMVK -> Int
$csizeOf :: VkMacOSSurfaceCreateFlagsMVK -> Int
Storable)

instance Show VkMacOSSurfaceCreateFlagsMVK where
    {-# INLINE showsPrec #-}
    showsPrec :: Int -> VkMacOSSurfaceCreateFlagsMVK -> ShowS
showsPrec = (Int -> VkFlags -> ShowS)
-> Int -> VkMacOSSurfaceCreateFlagsMVK -> ShowS
coerce (Int -> VkFlags -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec :: Int -> VkFlags -> ShowS)

instance Read VkMacOSSurfaceCreateFlagsMVK where
    {-# INLINE readsPrec #-}
    readsPrec :: Int -> ReadS VkMacOSSurfaceCreateFlagsMVK
readsPrec = (Int -> ReadS VkFlags) -> Int -> ReadS VkMacOSSurfaceCreateFlagsMVK
coerce (Int -> ReadS VkFlags
forall a. Read a => Int -> ReadS a
readsPrec :: Int -> ReadS VkFlags)

newtype VkMemoryAllocateFlagsKHR = VkMemoryAllocateFlagsKHR VkFlags
                                   deriving (VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR -> Bool
(VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR -> Bool)
-> (VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR -> Bool)
-> Eq VkMemoryAllocateFlagsKHR
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR -> Bool
$c/= :: VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR -> Bool
== :: VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR -> Bool
$c== :: VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR -> Bool
Eq, Eq VkMemoryAllocateFlagsKHR
Eq VkMemoryAllocateFlagsKHR
-> (VkMemoryAllocateFlagsKHR
    -> VkMemoryAllocateFlagsKHR -> Ordering)
-> (VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR -> Bool)
-> (VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR -> Bool)
-> (VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR -> Bool)
-> (VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR -> Bool)
-> (VkMemoryAllocateFlagsKHR
    -> VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR)
-> (VkMemoryAllocateFlagsKHR
    -> VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR)
-> Ord VkMemoryAllocateFlagsKHR
VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR -> Bool
VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR -> Ordering
VkMemoryAllocateFlagsKHR
-> VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: VkMemoryAllocateFlagsKHR
-> VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR
$cmin :: VkMemoryAllocateFlagsKHR
-> VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR
max :: VkMemoryAllocateFlagsKHR
-> VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR
$cmax :: VkMemoryAllocateFlagsKHR
-> VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR
>= :: VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR -> Bool
$c>= :: VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR -> Bool
> :: VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR -> Bool
$c> :: VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR -> Bool
<= :: VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR -> Bool
$c<= :: VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR -> Bool
< :: VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR -> Bool
$c< :: VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR -> Bool
compare :: VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR -> Ordering
$ccompare :: VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR -> Ordering
Ord, Int -> VkMemoryAllocateFlagsKHR
VkMemoryAllocateFlagsKHR -> Int
VkMemoryAllocateFlagsKHR -> [VkMemoryAllocateFlagsKHR]
VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR
VkMemoryAllocateFlagsKHR
-> VkMemoryAllocateFlagsKHR -> [VkMemoryAllocateFlagsKHR]
VkMemoryAllocateFlagsKHR
-> VkMemoryAllocateFlagsKHR
-> VkMemoryAllocateFlagsKHR
-> [VkMemoryAllocateFlagsKHR]
(VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR)
-> (VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR)
-> (Int -> VkMemoryAllocateFlagsKHR)
-> (VkMemoryAllocateFlagsKHR -> Int)
-> (VkMemoryAllocateFlagsKHR -> [VkMemoryAllocateFlagsKHR])
-> (VkMemoryAllocateFlagsKHR
    -> VkMemoryAllocateFlagsKHR -> [VkMemoryAllocateFlagsKHR])
-> (VkMemoryAllocateFlagsKHR
    -> VkMemoryAllocateFlagsKHR -> [VkMemoryAllocateFlagsKHR])
-> (VkMemoryAllocateFlagsKHR
    -> VkMemoryAllocateFlagsKHR
    -> VkMemoryAllocateFlagsKHR
    -> [VkMemoryAllocateFlagsKHR])
-> Enum VkMemoryAllocateFlagsKHR
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: VkMemoryAllocateFlagsKHR
-> VkMemoryAllocateFlagsKHR
-> VkMemoryAllocateFlagsKHR
-> [VkMemoryAllocateFlagsKHR]
$cenumFromThenTo :: VkMemoryAllocateFlagsKHR
-> VkMemoryAllocateFlagsKHR
-> VkMemoryAllocateFlagsKHR
-> [VkMemoryAllocateFlagsKHR]
enumFromTo :: VkMemoryAllocateFlagsKHR
-> VkMemoryAllocateFlagsKHR -> [VkMemoryAllocateFlagsKHR]
$cenumFromTo :: VkMemoryAllocateFlagsKHR
-> VkMemoryAllocateFlagsKHR -> [VkMemoryAllocateFlagsKHR]
enumFromThen :: VkMemoryAllocateFlagsKHR
-> VkMemoryAllocateFlagsKHR -> [VkMemoryAllocateFlagsKHR]
$cenumFromThen :: VkMemoryAllocateFlagsKHR
-> VkMemoryAllocateFlagsKHR -> [VkMemoryAllocateFlagsKHR]
enumFrom :: VkMemoryAllocateFlagsKHR -> [VkMemoryAllocateFlagsKHR]
$cenumFrom :: VkMemoryAllocateFlagsKHR -> [VkMemoryAllocateFlagsKHR]
fromEnum :: VkMemoryAllocateFlagsKHR -> Int
$cfromEnum :: VkMemoryAllocateFlagsKHR -> Int
toEnum :: Int -> VkMemoryAllocateFlagsKHR
$ctoEnum :: Int -> VkMemoryAllocateFlagsKHR
pred :: VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR
$cpred :: VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR
succ :: VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR
$csucc :: VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR
Enum, Eq VkMemoryAllocateFlagsKHR
VkMemoryAllocateFlagsKHR
Eq VkMemoryAllocateFlagsKHR
-> (VkMemoryAllocateFlagsKHR
    -> VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR)
-> (VkMemoryAllocateFlagsKHR
    -> VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR)
-> (VkMemoryAllocateFlagsKHR
    -> VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR)
-> (VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR)
-> (VkMemoryAllocateFlagsKHR -> Int -> VkMemoryAllocateFlagsKHR)
-> (VkMemoryAllocateFlagsKHR -> Int -> VkMemoryAllocateFlagsKHR)
-> VkMemoryAllocateFlagsKHR
-> (Int -> VkMemoryAllocateFlagsKHR)
-> (VkMemoryAllocateFlagsKHR -> Int -> VkMemoryAllocateFlagsKHR)
-> (VkMemoryAllocateFlagsKHR -> Int -> VkMemoryAllocateFlagsKHR)
-> (VkMemoryAllocateFlagsKHR -> Int -> VkMemoryAllocateFlagsKHR)
-> (VkMemoryAllocateFlagsKHR -> Int -> Bool)
-> (VkMemoryAllocateFlagsKHR -> Maybe Int)
-> (VkMemoryAllocateFlagsKHR -> Int)
-> (VkMemoryAllocateFlagsKHR -> Bool)
-> (VkMemoryAllocateFlagsKHR -> Int -> VkMemoryAllocateFlagsKHR)
-> (VkMemoryAllocateFlagsKHR -> Int -> VkMemoryAllocateFlagsKHR)
-> (VkMemoryAllocateFlagsKHR -> Int -> VkMemoryAllocateFlagsKHR)
-> (VkMemoryAllocateFlagsKHR -> Int -> VkMemoryAllocateFlagsKHR)
-> (VkMemoryAllocateFlagsKHR -> Int -> VkMemoryAllocateFlagsKHR)
-> (VkMemoryAllocateFlagsKHR -> Int -> VkMemoryAllocateFlagsKHR)
-> (VkMemoryAllocateFlagsKHR -> Int)
-> Bits VkMemoryAllocateFlagsKHR
Int -> VkMemoryAllocateFlagsKHR
VkMemoryAllocateFlagsKHR -> Bool
VkMemoryAllocateFlagsKHR -> Int
VkMemoryAllocateFlagsKHR -> Maybe Int
VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR
VkMemoryAllocateFlagsKHR -> Int -> Bool
VkMemoryAllocateFlagsKHR -> Int -> VkMemoryAllocateFlagsKHR
VkMemoryAllocateFlagsKHR
-> VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR
forall a.
Eq a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
popCount :: VkMemoryAllocateFlagsKHR -> Int
$cpopCount :: VkMemoryAllocateFlagsKHR -> Int
rotateR :: VkMemoryAllocateFlagsKHR -> Int -> VkMemoryAllocateFlagsKHR
$crotateR :: VkMemoryAllocateFlagsKHR -> Int -> VkMemoryAllocateFlagsKHR
rotateL :: VkMemoryAllocateFlagsKHR -> Int -> VkMemoryAllocateFlagsKHR
$crotateL :: VkMemoryAllocateFlagsKHR -> Int -> VkMemoryAllocateFlagsKHR
unsafeShiftR :: VkMemoryAllocateFlagsKHR -> Int -> VkMemoryAllocateFlagsKHR
$cunsafeShiftR :: VkMemoryAllocateFlagsKHR -> Int -> VkMemoryAllocateFlagsKHR
shiftR :: VkMemoryAllocateFlagsKHR -> Int -> VkMemoryAllocateFlagsKHR
$cshiftR :: VkMemoryAllocateFlagsKHR -> Int -> VkMemoryAllocateFlagsKHR
unsafeShiftL :: VkMemoryAllocateFlagsKHR -> Int -> VkMemoryAllocateFlagsKHR
$cunsafeShiftL :: VkMemoryAllocateFlagsKHR -> Int -> VkMemoryAllocateFlagsKHR
shiftL :: VkMemoryAllocateFlagsKHR -> Int -> VkMemoryAllocateFlagsKHR
$cshiftL :: VkMemoryAllocateFlagsKHR -> Int -> VkMemoryAllocateFlagsKHR
isSigned :: VkMemoryAllocateFlagsKHR -> Bool
$cisSigned :: VkMemoryAllocateFlagsKHR -> Bool
bitSize :: VkMemoryAllocateFlagsKHR -> Int
$cbitSize :: VkMemoryAllocateFlagsKHR -> Int
bitSizeMaybe :: VkMemoryAllocateFlagsKHR -> Maybe Int
$cbitSizeMaybe :: VkMemoryAllocateFlagsKHR -> Maybe Int
testBit :: VkMemoryAllocateFlagsKHR -> Int -> Bool
$ctestBit :: VkMemoryAllocateFlagsKHR -> Int -> Bool
complementBit :: VkMemoryAllocateFlagsKHR -> Int -> VkMemoryAllocateFlagsKHR
$ccomplementBit :: VkMemoryAllocateFlagsKHR -> Int -> VkMemoryAllocateFlagsKHR
clearBit :: VkMemoryAllocateFlagsKHR -> Int -> VkMemoryAllocateFlagsKHR
$cclearBit :: VkMemoryAllocateFlagsKHR -> Int -> VkMemoryAllocateFlagsKHR
setBit :: VkMemoryAllocateFlagsKHR -> Int -> VkMemoryAllocateFlagsKHR
$csetBit :: VkMemoryAllocateFlagsKHR -> Int -> VkMemoryAllocateFlagsKHR
bit :: Int -> VkMemoryAllocateFlagsKHR
$cbit :: Int -> VkMemoryAllocateFlagsKHR
zeroBits :: VkMemoryAllocateFlagsKHR
$czeroBits :: VkMemoryAllocateFlagsKHR
rotate :: VkMemoryAllocateFlagsKHR -> Int -> VkMemoryAllocateFlagsKHR
$crotate :: VkMemoryAllocateFlagsKHR -> Int -> VkMemoryAllocateFlagsKHR
shift :: VkMemoryAllocateFlagsKHR -> Int -> VkMemoryAllocateFlagsKHR
$cshift :: VkMemoryAllocateFlagsKHR -> Int -> VkMemoryAllocateFlagsKHR
complement :: VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR
$ccomplement :: VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR
xor :: VkMemoryAllocateFlagsKHR
-> VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR
$cxor :: VkMemoryAllocateFlagsKHR
-> VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR
.|. :: VkMemoryAllocateFlagsKHR
-> VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR
$c.|. :: VkMemoryAllocateFlagsKHR
-> VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR
.&. :: VkMemoryAllocateFlagsKHR
-> VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR
$c.&. :: VkMemoryAllocateFlagsKHR
-> VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR
Bits, Bits VkMemoryAllocateFlagsKHR
Bits VkMemoryAllocateFlagsKHR
-> (VkMemoryAllocateFlagsKHR -> Int)
-> (VkMemoryAllocateFlagsKHR -> Int)
-> (VkMemoryAllocateFlagsKHR -> Int)
-> FiniteBits VkMemoryAllocateFlagsKHR
VkMemoryAllocateFlagsKHR -> Int
forall b.
Bits b -> (b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
countTrailingZeros :: VkMemoryAllocateFlagsKHR -> Int
$ccountTrailingZeros :: VkMemoryAllocateFlagsKHR -> Int
countLeadingZeros :: VkMemoryAllocateFlagsKHR -> Int
$ccountLeadingZeros :: VkMemoryAllocateFlagsKHR -> Int
finiteBitSize :: VkMemoryAllocateFlagsKHR -> Int
$cfiniteBitSize :: VkMemoryAllocateFlagsKHR -> Int
FiniteBits, Ptr VkMemoryAllocateFlagsKHR -> IO VkMemoryAllocateFlagsKHR
Ptr VkMemoryAllocateFlagsKHR -> Int -> IO VkMemoryAllocateFlagsKHR
Ptr VkMemoryAllocateFlagsKHR
-> Int -> VkMemoryAllocateFlagsKHR -> IO ()
Ptr VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR -> IO ()
VkMemoryAllocateFlagsKHR -> Int
(VkMemoryAllocateFlagsKHR -> Int)
-> (VkMemoryAllocateFlagsKHR -> Int)
-> (Ptr VkMemoryAllocateFlagsKHR
    -> Int -> IO VkMemoryAllocateFlagsKHR)
-> (Ptr VkMemoryAllocateFlagsKHR
    -> Int -> VkMemoryAllocateFlagsKHR -> IO ())
-> (forall b. Ptr b -> Int -> IO VkMemoryAllocateFlagsKHR)
-> (forall b. Ptr b -> Int -> VkMemoryAllocateFlagsKHR -> IO ())
-> (Ptr VkMemoryAllocateFlagsKHR -> IO VkMemoryAllocateFlagsKHR)
-> (Ptr VkMemoryAllocateFlagsKHR
    -> VkMemoryAllocateFlagsKHR -> IO ())
-> Storable VkMemoryAllocateFlagsKHR
forall b. Ptr b -> Int -> IO VkMemoryAllocateFlagsKHR
forall b. Ptr b -> Int -> VkMemoryAllocateFlagsKHR -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR -> IO ()
$cpoke :: Ptr VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR -> IO ()
peek :: Ptr VkMemoryAllocateFlagsKHR -> IO VkMemoryAllocateFlagsKHR
$cpeek :: Ptr VkMemoryAllocateFlagsKHR -> IO VkMemoryAllocateFlagsKHR
pokeByteOff :: forall b. Ptr b -> Int -> VkMemoryAllocateFlagsKHR -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> VkMemoryAllocateFlagsKHR -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO VkMemoryAllocateFlagsKHR
$cpeekByteOff :: forall b. Ptr b -> Int -> IO VkMemoryAllocateFlagsKHR
pokeElemOff :: Ptr VkMemoryAllocateFlagsKHR
-> Int -> VkMemoryAllocateFlagsKHR -> IO ()
$cpokeElemOff :: Ptr VkMemoryAllocateFlagsKHR
-> Int -> VkMemoryAllocateFlagsKHR -> IO ()
peekElemOff :: Ptr VkMemoryAllocateFlagsKHR -> Int -> IO VkMemoryAllocateFlagsKHR
$cpeekElemOff :: Ptr VkMemoryAllocateFlagsKHR -> Int -> IO VkMemoryAllocateFlagsKHR
alignment :: VkMemoryAllocateFlagsKHR -> Int
$calignment :: VkMemoryAllocateFlagsKHR -> Int
sizeOf :: VkMemoryAllocateFlagsKHR -> Int
$csizeOf :: VkMemoryAllocateFlagsKHR -> Int
Storable)

instance Show VkMemoryAllocateFlagsKHR where
    {-# INLINE showsPrec #-}
    showsPrec :: Int -> VkMemoryAllocateFlagsKHR -> ShowS
showsPrec = (Int -> VkFlags -> ShowS)
-> Int -> VkMemoryAllocateFlagsKHR -> ShowS
coerce (Int -> VkFlags -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec :: Int -> VkFlags -> ShowS)

instance Read VkMemoryAllocateFlagsKHR where
    {-# INLINE readsPrec #-}
    readsPrec :: Int -> ReadS VkMemoryAllocateFlagsKHR
readsPrec = (Int -> ReadS VkFlags) -> Int -> ReadS VkMemoryAllocateFlagsKHR
coerce (Int -> ReadS VkFlags
forall a. Read a => Int -> ReadS a
readsPrec :: Int -> ReadS VkFlags)

newtype VkMemoryMapFlags = VkMemoryMapFlags VkFlags
                           deriving (VkMemoryMapFlags -> VkMemoryMapFlags -> Bool
(VkMemoryMapFlags -> VkMemoryMapFlags -> Bool)
-> (VkMemoryMapFlags -> VkMemoryMapFlags -> Bool)
-> Eq VkMemoryMapFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VkMemoryMapFlags -> VkMemoryMapFlags -> Bool
$c/= :: VkMemoryMapFlags -> VkMemoryMapFlags -> Bool
== :: VkMemoryMapFlags -> VkMemoryMapFlags -> Bool
$c== :: VkMemoryMapFlags -> VkMemoryMapFlags -> Bool
Eq, Eq VkMemoryMapFlags
Eq VkMemoryMapFlags
-> (VkMemoryMapFlags -> VkMemoryMapFlags -> Ordering)
-> (VkMemoryMapFlags -> VkMemoryMapFlags -> Bool)
-> (VkMemoryMapFlags -> VkMemoryMapFlags -> Bool)
-> (VkMemoryMapFlags -> VkMemoryMapFlags -> Bool)
-> (VkMemoryMapFlags -> VkMemoryMapFlags -> Bool)
-> (VkMemoryMapFlags -> VkMemoryMapFlags -> VkMemoryMapFlags)
-> (VkMemoryMapFlags -> VkMemoryMapFlags -> VkMemoryMapFlags)
-> Ord VkMemoryMapFlags
VkMemoryMapFlags -> VkMemoryMapFlags -> Bool
VkMemoryMapFlags -> VkMemoryMapFlags -> Ordering
VkMemoryMapFlags -> VkMemoryMapFlags -> VkMemoryMapFlags
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: VkMemoryMapFlags -> VkMemoryMapFlags -> VkMemoryMapFlags
$cmin :: VkMemoryMapFlags -> VkMemoryMapFlags -> VkMemoryMapFlags
max :: VkMemoryMapFlags -> VkMemoryMapFlags -> VkMemoryMapFlags
$cmax :: VkMemoryMapFlags -> VkMemoryMapFlags -> VkMemoryMapFlags
>= :: VkMemoryMapFlags -> VkMemoryMapFlags -> Bool
$c>= :: VkMemoryMapFlags -> VkMemoryMapFlags -> Bool
> :: VkMemoryMapFlags -> VkMemoryMapFlags -> Bool
$c> :: VkMemoryMapFlags -> VkMemoryMapFlags -> Bool
<= :: VkMemoryMapFlags -> VkMemoryMapFlags -> Bool
$c<= :: VkMemoryMapFlags -> VkMemoryMapFlags -> Bool
< :: VkMemoryMapFlags -> VkMemoryMapFlags -> Bool
$c< :: VkMemoryMapFlags -> VkMemoryMapFlags -> Bool
compare :: VkMemoryMapFlags -> VkMemoryMapFlags -> Ordering
$ccompare :: VkMemoryMapFlags -> VkMemoryMapFlags -> Ordering
Ord, Int -> VkMemoryMapFlags
VkMemoryMapFlags -> Int
VkMemoryMapFlags -> [VkMemoryMapFlags]
VkMemoryMapFlags -> VkMemoryMapFlags
VkMemoryMapFlags -> VkMemoryMapFlags -> [VkMemoryMapFlags]
VkMemoryMapFlags
-> VkMemoryMapFlags -> VkMemoryMapFlags -> [VkMemoryMapFlags]
(VkMemoryMapFlags -> VkMemoryMapFlags)
-> (VkMemoryMapFlags -> VkMemoryMapFlags)
-> (Int -> VkMemoryMapFlags)
-> (VkMemoryMapFlags -> Int)
-> (VkMemoryMapFlags -> [VkMemoryMapFlags])
-> (VkMemoryMapFlags -> VkMemoryMapFlags -> [VkMemoryMapFlags])
-> (VkMemoryMapFlags -> VkMemoryMapFlags -> [VkMemoryMapFlags])
-> (VkMemoryMapFlags
    -> VkMemoryMapFlags -> VkMemoryMapFlags -> [VkMemoryMapFlags])
-> Enum VkMemoryMapFlags
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: VkMemoryMapFlags
-> VkMemoryMapFlags -> VkMemoryMapFlags -> [VkMemoryMapFlags]
$cenumFromThenTo :: VkMemoryMapFlags
-> VkMemoryMapFlags -> VkMemoryMapFlags -> [VkMemoryMapFlags]
enumFromTo :: VkMemoryMapFlags -> VkMemoryMapFlags -> [VkMemoryMapFlags]
$cenumFromTo :: VkMemoryMapFlags -> VkMemoryMapFlags -> [VkMemoryMapFlags]
enumFromThen :: VkMemoryMapFlags -> VkMemoryMapFlags -> [VkMemoryMapFlags]
$cenumFromThen :: VkMemoryMapFlags -> VkMemoryMapFlags -> [VkMemoryMapFlags]
enumFrom :: VkMemoryMapFlags -> [VkMemoryMapFlags]
$cenumFrom :: VkMemoryMapFlags -> [VkMemoryMapFlags]
fromEnum :: VkMemoryMapFlags -> Int
$cfromEnum :: VkMemoryMapFlags -> Int
toEnum :: Int -> VkMemoryMapFlags
$ctoEnum :: Int -> VkMemoryMapFlags
pred :: VkMemoryMapFlags -> VkMemoryMapFlags
$cpred :: VkMemoryMapFlags -> VkMemoryMapFlags
succ :: VkMemoryMapFlags -> VkMemoryMapFlags
$csucc :: VkMemoryMapFlags -> VkMemoryMapFlags
Enum, Eq VkMemoryMapFlags
VkMemoryMapFlags
Eq VkMemoryMapFlags
-> (VkMemoryMapFlags -> VkMemoryMapFlags -> VkMemoryMapFlags)
-> (VkMemoryMapFlags -> VkMemoryMapFlags -> VkMemoryMapFlags)
-> (VkMemoryMapFlags -> VkMemoryMapFlags -> VkMemoryMapFlags)
-> (VkMemoryMapFlags -> VkMemoryMapFlags)
-> (VkMemoryMapFlags -> Int -> VkMemoryMapFlags)
-> (VkMemoryMapFlags -> Int -> VkMemoryMapFlags)
-> VkMemoryMapFlags
-> (Int -> VkMemoryMapFlags)
-> (VkMemoryMapFlags -> Int -> VkMemoryMapFlags)
-> (VkMemoryMapFlags -> Int -> VkMemoryMapFlags)
-> (VkMemoryMapFlags -> Int -> VkMemoryMapFlags)
-> (VkMemoryMapFlags -> Int -> Bool)
-> (VkMemoryMapFlags -> Maybe Int)
-> (VkMemoryMapFlags -> Int)
-> (VkMemoryMapFlags -> Bool)
-> (VkMemoryMapFlags -> Int -> VkMemoryMapFlags)
-> (VkMemoryMapFlags -> Int -> VkMemoryMapFlags)
-> (VkMemoryMapFlags -> Int -> VkMemoryMapFlags)
-> (VkMemoryMapFlags -> Int -> VkMemoryMapFlags)
-> (VkMemoryMapFlags -> Int -> VkMemoryMapFlags)
-> (VkMemoryMapFlags -> Int -> VkMemoryMapFlags)
-> (VkMemoryMapFlags -> Int)
-> Bits VkMemoryMapFlags
Int -> VkMemoryMapFlags
VkMemoryMapFlags -> Bool
VkMemoryMapFlags -> Int
VkMemoryMapFlags -> Maybe Int
VkMemoryMapFlags -> VkMemoryMapFlags
VkMemoryMapFlags -> Int -> Bool
VkMemoryMapFlags -> Int -> VkMemoryMapFlags
VkMemoryMapFlags -> VkMemoryMapFlags -> VkMemoryMapFlags
forall a.
Eq a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
popCount :: VkMemoryMapFlags -> Int
$cpopCount :: VkMemoryMapFlags -> Int
rotateR :: VkMemoryMapFlags -> Int -> VkMemoryMapFlags
$crotateR :: VkMemoryMapFlags -> Int -> VkMemoryMapFlags
rotateL :: VkMemoryMapFlags -> Int -> VkMemoryMapFlags
$crotateL :: VkMemoryMapFlags -> Int -> VkMemoryMapFlags
unsafeShiftR :: VkMemoryMapFlags -> Int -> VkMemoryMapFlags
$cunsafeShiftR :: VkMemoryMapFlags -> Int -> VkMemoryMapFlags
shiftR :: VkMemoryMapFlags -> Int -> VkMemoryMapFlags
$cshiftR :: VkMemoryMapFlags -> Int -> VkMemoryMapFlags
unsafeShiftL :: VkMemoryMapFlags -> Int -> VkMemoryMapFlags
$cunsafeShiftL :: VkMemoryMapFlags -> Int -> VkMemoryMapFlags
shiftL :: VkMemoryMapFlags -> Int -> VkMemoryMapFlags
$cshiftL :: VkMemoryMapFlags -> Int -> VkMemoryMapFlags
isSigned :: VkMemoryMapFlags -> Bool
$cisSigned :: VkMemoryMapFlags -> Bool
bitSize :: VkMemoryMapFlags -> Int
$cbitSize :: VkMemoryMapFlags -> Int
bitSizeMaybe :: VkMemoryMapFlags -> Maybe Int
$cbitSizeMaybe :: VkMemoryMapFlags -> Maybe Int
testBit :: VkMemoryMapFlags -> Int -> Bool
$ctestBit :: VkMemoryMapFlags -> Int -> Bool
complementBit :: VkMemoryMapFlags -> Int -> VkMemoryMapFlags
$ccomplementBit :: VkMemoryMapFlags -> Int -> VkMemoryMapFlags
clearBit :: VkMemoryMapFlags -> Int -> VkMemoryMapFlags
$cclearBit :: VkMemoryMapFlags -> Int -> VkMemoryMapFlags
setBit :: VkMemoryMapFlags -> Int -> VkMemoryMapFlags
$csetBit :: VkMemoryMapFlags -> Int -> VkMemoryMapFlags
bit :: Int -> VkMemoryMapFlags
$cbit :: Int -> VkMemoryMapFlags
zeroBits :: VkMemoryMapFlags
$czeroBits :: VkMemoryMapFlags
rotate :: VkMemoryMapFlags -> Int -> VkMemoryMapFlags
$crotate :: VkMemoryMapFlags -> Int -> VkMemoryMapFlags
shift :: VkMemoryMapFlags -> Int -> VkMemoryMapFlags
$cshift :: VkMemoryMapFlags -> Int -> VkMemoryMapFlags
complement :: VkMemoryMapFlags -> VkMemoryMapFlags
$ccomplement :: VkMemoryMapFlags -> VkMemoryMapFlags
xor :: VkMemoryMapFlags -> VkMemoryMapFlags -> VkMemoryMapFlags
$cxor :: VkMemoryMapFlags -> VkMemoryMapFlags -> VkMemoryMapFlags
.|. :: VkMemoryMapFlags -> VkMemoryMapFlags -> VkMemoryMapFlags
$c.|. :: VkMemoryMapFlags -> VkMemoryMapFlags -> VkMemoryMapFlags
.&. :: VkMemoryMapFlags -> VkMemoryMapFlags -> VkMemoryMapFlags
$c.&. :: VkMemoryMapFlags -> VkMemoryMapFlags -> VkMemoryMapFlags
Bits, Bits VkMemoryMapFlags
Bits VkMemoryMapFlags
-> (VkMemoryMapFlags -> Int)
-> (VkMemoryMapFlags -> Int)
-> (VkMemoryMapFlags -> Int)
-> FiniteBits VkMemoryMapFlags
VkMemoryMapFlags -> Int
forall b.
Bits b -> (b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
countTrailingZeros :: VkMemoryMapFlags -> Int
$ccountTrailingZeros :: VkMemoryMapFlags -> Int
countLeadingZeros :: VkMemoryMapFlags -> Int
$ccountLeadingZeros :: VkMemoryMapFlags -> Int
finiteBitSize :: VkMemoryMapFlags -> Int
$cfiniteBitSize :: VkMemoryMapFlags -> Int
FiniteBits, Ptr VkMemoryMapFlags -> IO VkMemoryMapFlags
Ptr VkMemoryMapFlags -> Int -> IO VkMemoryMapFlags
Ptr VkMemoryMapFlags -> Int -> VkMemoryMapFlags -> IO ()
Ptr VkMemoryMapFlags -> VkMemoryMapFlags -> IO ()
VkMemoryMapFlags -> Int
(VkMemoryMapFlags -> Int)
-> (VkMemoryMapFlags -> Int)
-> (Ptr VkMemoryMapFlags -> Int -> IO VkMemoryMapFlags)
-> (Ptr VkMemoryMapFlags -> Int -> VkMemoryMapFlags -> IO ())
-> (forall b. Ptr b -> Int -> IO VkMemoryMapFlags)
-> (forall b. Ptr b -> Int -> VkMemoryMapFlags -> IO ())
-> (Ptr VkMemoryMapFlags -> IO VkMemoryMapFlags)
-> (Ptr VkMemoryMapFlags -> VkMemoryMapFlags -> IO ())
-> Storable VkMemoryMapFlags
forall b. Ptr b -> Int -> IO VkMemoryMapFlags
forall b. Ptr b -> Int -> VkMemoryMapFlags -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr VkMemoryMapFlags -> VkMemoryMapFlags -> IO ()
$cpoke :: Ptr VkMemoryMapFlags -> VkMemoryMapFlags -> IO ()
peek :: Ptr VkMemoryMapFlags -> IO VkMemoryMapFlags
$cpeek :: Ptr VkMemoryMapFlags -> IO VkMemoryMapFlags
pokeByteOff :: forall b. Ptr b -> Int -> VkMemoryMapFlags -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> VkMemoryMapFlags -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO VkMemoryMapFlags
$cpeekByteOff :: forall b. Ptr b -> Int -> IO VkMemoryMapFlags
pokeElemOff :: Ptr VkMemoryMapFlags -> Int -> VkMemoryMapFlags -> IO ()
$cpokeElemOff :: Ptr VkMemoryMapFlags -> Int -> VkMemoryMapFlags -> IO ()
peekElemOff :: Ptr VkMemoryMapFlags -> Int -> IO VkMemoryMapFlags
$cpeekElemOff :: Ptr VkMemoryMapFlags -> Int -> IO VkMemoryMapFlags
alignment :: VkMemoryMapFlags -> Int
$calignment :: VkMemoryMapFlags -> Int
sizeOf :: VkMemoryMapFlags -> Int
$csizeOf :: VkMemoryMapFlags -> Int
Storable)

instance Show VkMemoryMapFlags where
    {-# INLINE showsPrec #-}
    showsPrec :: Int -> VkMemoryMapFlags -> ShowS
showsPrec = (Int -> VkFlags -> ShowS) -> Int -> VkMemoryMapFlags -> ShowS
coerce (Int -> VkFlags -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec :: Int -> VkFlags -> ShowS)

instance Read VkMemoryMapFlags where
    {-# INLINE readsPrec #-}
    readsPrec :: Int -> ReadS VkMemoryMapFlags
readsPrec = (Int -> ReadS VkFlags) -> Int -> ReadS VkMemoryMapFlags
coerce (Int -> ReadS VkFlags
forall a. Read a => Int -> ReadS a
readsPrec :: Int -> ReadS VkFlags)

newtype VkMetalSurfaceCreateFlagsEXT = VkMetalSurfaceCreateFlagsEXT VkFlags
                                       deriving (VkMetalSurfaceCreateFlagsEXT
-> VkMetalSurfaceCreateFlagsEXT -> Bool
(VkMetalSurfaceCreateFlagsEXT
 -> VkMetalSurfaceCreateFlagsEXT -> Bool)
-> (VkMetalSurfaceCreateFlagsEXT
    -> VkMetalSurfaceCreateFlagsEXT -> Bool)
-> Eq VkMetalSurfaceCreateFlagsEXT
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VkMetalSurfaceCreateFlagsEXT
-> VkMetalSurfaceCreateFlagsEXT -> Bool
$c/= :: VkMetalSurfaceCreateFlagsEXT
-> VkMetalSurfaceCreateFlagsEXT -> Bool
== :: VkMetalSurfaceCreateFlagsEXT
-> VkMetalSurfaceCreateFlagsEXT -> Bool
$c== :: VkMetalSurfaceCreateFlagsEXT
-> VkMetalSurfaceCreateFlagsEXT -> Bool
Eq, Eq VkMetalSurfaceCreateFlagsEXT
Eq VkMetalSurfaceCreateFlagsEXT
-> (VkMetalSurfaceCreateFlagsEXT
    -> VkMetalSurfaceCreateFlagsEXT -> Ordering)
-> (VkMetalSurfaceCreateFlagsEXT
    -> VkMetalSurfaceCreateFlagsEXT -> Bool)
-> (VkMetalSurfaceCreateFlagsEXT
    -> VkMetalSurfaceCreateFlagsEXT -> Bool)
-> (VkMetalSurfaceCreateFlagsEXT
    -> VkMetalSurfaceCreateFlagsEXT -> Bool)
-> (VkMetalSurfaceCreateFlagsEXT
    -> VkMetalSurfaceCreateFlagsEXT -> Bool)
-> (VkMetalSurfaceCreateFlagsEXT
    -> VkMetalSurfaceCreateFlagsEXT -> VkMetalSurfaceCreateFlagsEXT)
-> (VkMetalSurfaceCreateFlagsEXT
    -> VkMetalSurfaceCreateFlagsEXT -> VkMetalSurfaceCreateFlagsEXT)
-> Ord VkMetalSurfaceCreateFlagsEXT
VkMetalSurfaceCreateFlagsEXT
-> VkMetalSurfaceCreateFlagsEXT -> Bool
VkMetalSurfaceCreateFlagsEXT
-> VkMetalSurfaceCreateFlagsEXT -> Ordering
VkMetalSurfaceCreateFlagsEXT
-> VkMetalSurfaceCreateFlagsEXT -> VkMetalSurfaceCreateFlagsEXT
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: VkMetalSurfaceCreateFlagsEXT
-> VkMetalSurfaceCreateFlagsEXT -> VkMetalSurfaceCreateFlagsEXT
$cmin :: VkMetalSurfaceCreateFlagsEXT
-> VkMetalSurfaceCreateFlagsEXT -> VkMetalSurfaceCreateFlagsEXT
max :: VkMetalSurfaceCreateFlagsEXT
-> VkMetalSurfaceCreateFlagsEXT -> VkMetalSurfaceCreateFlagsEXT
$cmax :: VkMetalSurfaceCreateFlagsEXT
-> VkMetalSurfaceCreateFlagsEXT -> VkMetalSurfaceCreateFlagsEXT
>= :: VkMetalSurfaceCreateFlagsEXT
-> VkMetalSurfaceCreateFlagsEXT -> Bool
$c>= :: VkMetalSurfaceCreateFlagsEXT
-> VkMetalSurfaceCreateFlagsEXT -> Bool
> :: VkMetalSurfaceCreateFlagsEXT
-> VkMetalSurfaceCreateFlagsEXT -> Bool
$c> :: VkMetalSurfaceCreateFlagsEXT
-> VkMetalSurfaceCreateFlagsEXT -> Bool
<= :: VkMetalSurfaceCreateFlagsEXT
-> VkMetalSurfaceCreateFlagsEXT -> Bool
$c<= :: VkMetalSurfaceCreateFlagsEXT
-> VkMetalSurfaceCreateFlagsEXT -> Bool
< :: VkMetalSurfaceCreateFlagsEXT
-> VkMetalSurfaceCreateFlagsEXT -> Bool
$c< :: VkMetalSurfaceCreateFlagsEXT
-> VkMetalSurfaceCreateFlagsEXT -> Bool
compare :: VkMetalSurfaceCreateFlagsEXT
-> VkMetalSurfaceCreateFlagsEXT -> Ordering
$ccompare :: VkMetalSurfaceCreateFlagsEXT
-> VkMetalSurfaceCreateFlagsEXT -> Ordering
Ord, Int -> VkMetalSurfaceCreateFlagsEXT
VkMetalSurfaceCreateFlagsEXT -> Int
VkMetalSurfaceCreateFlagsEXT -> [VkMetalSurfaceCreateFlagsEXT]
VkMetalSurfaceCreateFlagsEXT -> VkMetalSurfaceCreateFlagsEXT
VkMetalSurfaceCreateFlagsEXT
-> VkMetalSurfaceCreateFlagsEXT -> [VkMetalSurfaceCreateFlagsEXT]
VkMetalSurfaceCreateFlagsEXT
-> VkMetalSurfaceCreateFlagsEXT
-> VkMetalSurfaceCreateFlagsEXT
-> [VkMetalSurfaceCreateFlagsEXT]
(VkMetalSurfaceCreateFlagsEXT -> VkMetalSurfaceCreateFlagsEXT)
-> (VkMetalSurfaceCreateFlagsEXT -> VkMetalSurfaceCreateFlagsEXT)
-> (Int -> VkMetalSurfaceCreateFlagsEXT)
-> (VkMetalSurfaceCreateFlagsEXT -> Int)
-> (VkMetalSurfaceCreateFlagsEXT -> [VkMetalSurfaceCreateFlagsEXT])
-> (VkMetalSurfaceCreateFlagsEXT
    -> VkMetalSurfaceCreateFlagsEXT -> [VkMetalSurfaceCreateFlagsEXT])
-> (VkMetalSurfaceCreateFlagsEXT
    -> VkMetalSurfaceCreateFlagsEXT -> [VkMetalSurfaceCreateFlagsEXT])
-> (VkMetalSurfaceCreateFlagsEXT
    -> VkMetalSurfaceCreateFlagsEXT
    -> VkMetalSurfaceCreateFlagsEXT
    -> [VkMetalSurfaceCreateFlagsEXT])
-> Enum VkMetalSurfaceCreateFlagsEXT
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: VkMetalSurfaceCreateFlagsEXT
-> VkMetalSurfaceCreateFlagsEXT
-> VkMetalSurfaceCreateFlagsEXT
-> [VkMetalSurfaceCreateFlagsEXT]
$cenumFromThenTo :: VkMetalSurfaceCreateFlagsEXT
-> VkMetalSurfaceCreateFlagsEXT
-> VkMetalSurfaceCreateFlagsEXT
-> [VkMetalSurfaceCreateFlagsEXT]
enumFromTo :: VkMetalSurfaceCreateFlagsEXT
-> VkMetalSurfaceCreateFlagsEXT -> [VkMetalSurfaceCreateFlagsEXT]
$cenumFromTo :: VkMetalSurfaceCreateFlagsEXT
-> VkMetalSurfaceCreateFlagsEXT -> [VkMetalSurfaceCreateFlagsEXT]
enumFromThen :: VkMetalSurfaceCreateFlagsEXT
-> VkMetalSurfaceCreateFlagsEXT -> [VkMetalSurfaceCreateFlagsEXT]
$cenumFromThen :: VkMetalSurfaceCreateFlagsEXT
-> VkMetalSurfaceCreateFlagsEXT -> [VkMetalSurfaceCreateFlagsEXT]
enumFrom :: VkMetalSurfaceCreateFlagsEXT -> [VkMetalSurfaceCreateFlagsEXT]
$cenumFrom :: VkMetalSurfaceCreateFlagsEXT -> [VkMetalSurfaceCreateFlagsEXT]
fromEnum :: VkMetalSurfaceCreateFlagsEXT -> Int
$cfromEnum :: VkMetalSurfaceCreateFlagsEXT -> Int
toEnum :: Int -> VkMetalSurfaceCreateFlagsEXT
$ctoEnum :: Int -> VkMetalSurfaceCreateFlagsEXT
pred :: VkMetalSurfaceCreateFlagsEXT -> VkMetalSurfaceCreateFlagsEXT
$cpred :: VkMetalSurfaceCreateFlagsEXT -> VkMetalSurfaceCreateFlagsEXT
succ :: VkMetalSurfaceCreateFlagsEXT -> VkMetalSurfaceCreateFlagsEXT
$csucc :: VkMetalSurfaceCreateFlagsEXT -> VkMetalSurfaceCreateFlagsEXT
Enum, Eq VkMetalSurfaceCreateFlagsEXT
VkMetalSurfaceCreateFlagsEXT
Eq VkMetalSurfaceCreateFlagsEXT
-> (VkMetalSurfaceCreateFlagsEXT
    -> VkMetalSurfaceCreateFlagsEXT -> VkMetalSurfaceCreateFlagsEXT)
-> (VkMetalSurfaceCreateFlagsEXT
    -> VkMetalSurfaceCreateFlagsEXT -> VkMetalSurfaceCreateFlagsEXT)
-> (VkMetalSurfaceCreateFlagsEXT
    -> VkMetalSurfaceCreateFlagsEXT -> VkMetalSurfaceCreateFlagsEXT)
-> (VkMetalSurfaceCreateFlagsEXT -> VkMetalSurfaceCreateFlagsEXT)
-> (VkMetalSurfaceCreateFlagsEXT
    -> Int -> VkMetalSurfaceCreateFlagsEXT)
-> (VkMetalSurfaceCreateFlagsEXT
    -> Int -> VkMetalSurfaceCreateFlagsEXT)
-> VkMetalSurfaceCreateFlagsEXT
-> (Int -> VkMetalSurfaceCreateFlagsEXT)
-> (VkMetalSurfaceCreateFlagsEXT
    -> Int -> VkMetalSurfaceCreateFlagsEXT)
-> (VkMetalSurfaceCreateFlagsEXT
    -> Int -> VkMetalSurfaceCreateFlagsEXT)
-> (VkMetalSurfaceCreateFlagsEXT
    -> Int -> VkMetalSurfaceCreateFlagsEXT)
-> (VkMetalSurfaceCreateFlagsEXT -> Int -> Bool)
-> (VkMetalSurfaceCreateFlagsEXT -> Maybe Int)
-> (VkMetalSurfaceCreateFlagsEXT -> Int)
-> (VkMetalSurfaceCreateFlagsEXT -> Bool)
-> (VkMetalSurfaceCreateFlagsEXT
    -> Int -> VkMetalSurfaceCreateFlagsEXT)
-> (VkMetalSurfaceCreateFlagsEXT
    -> Int -> VkMetalSurfaceCreateFlagsEXT)
-> (VkMetalSurfaceCreateFlagsEXT
    -> Int -> VkMetalSurfaceCreateFlagsEXT)
-> (VkMetalSurfaceCreateFlagsEXT
    -> Int -> VkMetalSurfaceCreateFlagsEXT)
-> (VkMetalSurfaceCreateFlagsEXT
    -> Int -> VkMetalSurfaceCreateFlagsEXT)
-> (VkMetalSurfaceCreateFlagsEXT
    -> Int -> VkMetalSurfaceCreateFlagsEXT)
-> (VkMetalSurfaceCreateFlagsEXT -> Int)
-> Bits VkMetalSurfaceCreateFlagsEXT
Int -> VkMetalSurfaceCreateFlagsEXT
VkMetalSurfaceCreateFlagsEXT -> Bool
VkMetalSurfaceCreateFlagsEXT -> Int
VkMetalSurfaceCreateFlagsEXT -> Maybe Int
VkMetalSurfaceCreateFlagsEXT -> VkMetalSurfaceCreateFlagsEXT
VkMetalSurfaceCreateFlagsEXT -> Int -> Bool
VkMetalSurfaceCreateFlagsEXT -> Int -> VkMetalSurfaceCreateFlagsEXT
VkMetalSurfaceCreateFlagsEXT
-> VkMetalSurfaceCreateFlagsEXT -> VkMetalSurfaceCreateFlagsEXT
forall a.
Eq a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
popCount :: VkMetalSurfaceCreateFlagsEXT -> Int
$cpopCount :: VkMetalSurfaceCreateFlagsEXT -> Int
rotateR :: VkMetalSurfaceCreateFlagsEXT -> Int -> VkMetalSurfaceCreateFlagsEXT
$crotateR :: VkMetalSurfaceCreateFlagsEXT -> Int -> VkMetalSurfaceCreateFlagsEXT
rotateL :: VkMetalSurfaceCreateFlagsEXT -> Int -> VkMetalSurfaceCreateFlagsEXT
$crotateL :: VkMetalSurfaceCreateFlagsEXT -> Int -> VkMetalSurfaceCreateFlagsEXT
unsafeShiftR :: VkMetalSurfaceCreateFlagsEXT -> Int -> VkMetalSurfaceCreateFlagsEXT
$cunsafeShiftR :: VkMetalSurfaceCreateFlagsEXT -> Int -> VkMetalSurfaceCreateFlagsEXT
shiftR :: VkMetalSurfaceCreateFlagsEXT -> Int -> VkMetalSurfaceCreateFlagsEXT
$cshiftR :: VkMetalSurfaceCreateFlagsEXT -> Int -> VkMetalSurfaceCreateFlagsEXT
unsafeShiftL :: VkMetalSurfaceCreateFlagsEXT -> Int -> VkMetalSurfaceCreateFlagsEXT
$cunsafeShiftL :: VkMetalSurfaceCreateFlagsEXT -> Int -> VkMetalSurfaceCreateFlagsEXT
shiftL :: VkMetalSurfaceCreateFlagsEXT -> Int -> VkMetalSurfaceCreateFlagsEXT
$cshiftL :: VkMetalSurfaceCreateFlagsEXT -> Int -> VkMetalSurfaceCreateFlagsEXT
isSigned :: VkMetalSurfaceCreateFlagsEXT -> Bool
$cisSigned :: VkMetalSurfaceCreateFlagsEXT -> Bool
bitSize :: VkMetalSurfaceCreateFlagsEXT -> Int
$cbitSize :: VkMetalSurfaceCreateFlagsEXT -> Int
bitSizeMaybe :: VkMetalSurfaceCreateFlagsEXT -> Maybe Int
$cbitSizeMaybe :: VkMetalSurfaceCreateFlagsEXT -> Maybe Int
testBit :: VkMetalSurfaceCreateFlagsEXT -> Int -> Bool
$ctestBit :: VkMetalSurfaceCreateFlagsEXT -> Int -> Bool
complementBit :: VkMetalSurfaceCreateFlagsEXT -> Int -> VkMetalSurfaceCreateFlagsEXT
$ccomplementBit :: VkMetalSurfaceCreateFlagsEXT -> Int -> VkMetalSurfaceCreateFlagsEXT
clearBit :: VkMetalSurfaceCreateFlagsEXT -> Int -> VkMetalSurfaceCreateFlagsEXT
$cclearBit :: VkMetalSurfaceCreateFlagsEXT -> Int -> VkMetalSurfaceCreateFlagsEXT
setBit :: VkMetalSurfaceCreateFlagsEXT -> Int -> VkMetalSurfaceCreateFlagsEXT
$csetBit :: VkMetalSurfaceCreateFlagsEXT -> Int -> VkMetalSurfaceCreateFlagsEXT
bit :: Int -> VkMetalSurfaceCreateFlagsEXT
$cbit :: Int -> VkMetalSurfaceCreateFlagsEXT
zeroBits :: VkMetalSurfaceCreateFlagsEXT
$czeroBits :: VkMetalSurfaceCreateFlagsEXT
rotate :: VkMetalSurfaceCreateFlagsEXT -> Int -> VkMetalSurfaceCreateFlagsEXT
$crotate :: VkMetalSurfaceCreateFlagsEXT -> Int -> VkMetalSurfaceCreateFlagsEXT
shift :: VkMetalSurfaceCreateFlagsEXT -> Int -> VkMetalSurfaceCreateFlagsEXT
$cshift :: VkMetalSurfaceCreateFlagsEXT -> Int -> VkMetalSurfaceCreateFlagsEXT
complement :: VkMetalSurfaceCreateFlagsEXT -> VkMetalSurfaceCreateFlagsEXT
$ccomplement :: VkMetalSurfaceCreateFlagsEXT -> VkMetalSurfaceCreateFlagsEXT
xor :: VkMetalSurfaceCreateFlagsEXT
-> VkMetalSurfaceCreateFlagsEXT -> VkMetalSurfaceCreateFlagsEXT
$cxor :: VkMetalSurfaceCreateFlagsEXT
-> VkMetalSurfaceCreateFlagsEXT -> VkMetalSurfaceCreateFlagsEXT
.|. :: VkMetalSurfaceCreateFlagsEXT
-> VkMetalSurfaceCreateFlagsEXT -> VkMetalSurfaceCreateFlagsEXT
$c.|. :: VkMetalSurfaceCreateFlagsEXT
-> VkMetalSurfaceCreateFlagsEXT -> VkMetalSurfaceCreateFlagsEXT
.&. :: VkMetalSurfaceCreateFlagsEXT
-> VkMetalSurfaceCreateFlagsEXT -> VkMetalSurfaceCreateFlagsEXT
$c.&. :: VkMetalSurfaceCreateFlagsEXT
-> VkMetalSurfaceCreateFlagsEXT -> VkMetalSurfaceCreateFlagsEXT
Bits, Bits VkMetalSurfaceCreateFlagsEXT
Bits VkMetalSurfaceCreateFlagsEXT
-> (VkMetalSurfaceCreateFlagsEXT -> Int)
-> (VkMetalSurfaceCreateFlagsEXT -> Int)
-> (VkMetalSurfaceCreateFlagsEXT -> Int)
-> FiniteBits VkMetalSurfaceCreateFlagsEXT
VkMetalSurfaceCreateFlagsEXT -> Int
forall b.
Bits b -> (b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
countTrailingZeros :: VkMetalSurfaceCreateFlagsEXT -> Int
$ccountTrailingZeros :: VkMetalSurfaceCreateFlagsEXT -> Int
countLeadingZeros :: VkMetalSurfaceCreateFlagsEXT -> Int
$ccountLeadingZeros :: VkMetalSurfaceCreateFlagsEXT -> Int
finiteBitSize :: VkMetalSurfaceCreateFlagsEXT -> Int
$cfiniteBitSize :: VkMetalSurfaceCreateFlagsEXT -> Int
FiniteBits, Ptr VkMetalSurfaceCreateFlagsEXT -> IO VkMetalSurfaceCreateFlagsEXT
Ptr VkMetalSurfaceCreateFlagsEXT
-> Int -> IO VkMetalSurfaceCreateFlagsEXT
Ptr VkMetalSurfaceCreateFlagsEXT
-> Int -> VkMetalSurfaceCreateFlagsEXT -> IO ()
Ptr VkMetalSurfaceCreateFlagsEXT
-> VkMetalSurfaceCreateFlagsEXT -> IO ()
VkMetalSurfaceCreateFlagsEXT -> Int
(VkMetalSurfaceCreateFlagsEXT -> Int)
-> (VkMetalSurfaceCreateFlagsEXT -> Int)
-> (Ptr VkMetalSurfaceCreateFlagsEXT
    -> Int -> IO VkMetalSurfaceCreateFlagsEXT)
-> (Ptr VkMetalSurfaceCreateFlagsEXT
    -> Int -> VkMetalSurfaceCreateFlagsEXT -> IO ())
-> (forall b. Ptr b -> Int -> IO VkMetalSurfaceCreateFlagsEXT)
-> (forall b.
    Ptr b -> Int -> VkMetalSurfaceCreateFlagsEXT -> IO ())
-> (Ptr VkMetalSurfaceCreateFlagsEXT
    -> IO VkMetalSurfaceCreateFlagsEXT)
-> (Ptr VkMetalSurfaceCreateFlagsEXT
    -> VkMetalSurfaceCreateFlagsEXT -> IO ())
-> Storable VkMetalSurfaceCreateFlagsEXT
forall b. Ptr b -> Int -> IO VkMetalSurfaceCreateFlagsEXT
forall b. Ptr b -> Int -> VkMetalSurfaceCreateFlagsEXT -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr VkMetalSurfaceCreateFlagsEXT
-> VkMetalSurfaceCreateFlagsEXT -> IO ()
$cpoke :: Ptr VkMetalSurfaceCreateFlagsEXT
-> VkMetalSurfaceCreateFlagsEXT -> IO ()
peek :: Ptr VkMetalSurfaceCreateFlagsEXT -> IO VkMetalSurfaceCreateFlagsEXT
$cpeek :: Ptr VkMetalSurfaceCreateFlagsEXT -> IO VkMetalSurfaceCreateFlagsEXT
pokeByteOff :: forall b. Ptr b -> Int -> VkMetalSurfaceCreateFlagsEXT -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> VkMetalSurfaceCreateFlagsEXT -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO VkMetalSurfaceCreateFlagsEXT
$cpeekByteOff :: forall b. Ptr b -> Int -> IO VkMetalSurfaceCreateFlagsEXT
pokeElemOff :: Ptr VkMetalSurfaceCreateFlagsEXT
-> Int -> VkMetalSurfaceCreateFlagsEXT -> IO ()
$cpokeElemOff :: Ptr VkMetalSurfaceCreateFlagsEXT
-> Int -> VkMetalSurfaceCreateFlagsEXT -> IO ()
peekElemOff :: Ptr VkMetalSurfaceCreateFlagsEXT
-> Int -> IO VkMetalSurfaceCreateFlagsEXT
$cpeekElemOff :: Ptr VkMetalSurfaceCreateFlagsEXT
-> Int -> IO VkMetalSurfaceCreateFlagsEXT
alignment :: VkMetalSurfaceCreateFlagsEXT -> Int
$calignment :: VkMetalSurfaceCreateFlagsEXT -> Int
sizeOf :: VkMetalSurfaceCreateFlagsEXT -> Int
$csizeOf :: VkMetalSurfaceCreateFlagsEXT -> Int
Storable)

instance Show VkMetalSurfaceCreateFlagsEXT where
    {-# INLINE showsPrec #-}
    showsPrec :: Int -> VkMetalSurfaceCreateFlagsEXT -> ShowS
showsPrec = (Int -> VkFlags -> ShowS)
-> Int -> VkMetalSurfaceCreateFlagsEXT -> ShowS
coerce (Int -> VkFlags -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec :: Int -> VkFlags -> ShowS)

instance Read VkMetalSurfaceCreateFlagsEXT where
    {-# INLINE readsPrec #-}
    readsPrec :: Int -> ReadS VkMetalSurfaceCreateFlagsEXT
readsPrec = (Int -> ReadS VkFlags) -> Int -> ReadS VkMetalSurfaceCreateFlagsEXT
coerce (Int -> ReadS VkFlags
forall a. Read a => Int -> ReadS a
readsPrec :: Int -> ReadS VkFlags)

newtype VkPeerMemoryFeatureFlagsKHR = VkPeerMemoryFeatureFlagsKHR VkFlags
                                      deriving (VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR -> Bool
(VkPeerMemoryFeatureFlagsKHR
 -> VkPeerMemoryFeatureFlagsKHR -> Bool)
-> (VkPeerMemoryFeatureFlagsKHR
    -> VkPeerMemoryFeatureFlagsKHR -> Bool)
-> Eq VkPeerMemoryFeatureFlagsKHR
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR -> Bool
$c/= :: VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR -> Bool
== :: VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR -> Bool
$c== :: VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR -> Bool
Eq, Eq VkPeerMemoryFeatureFlagsKHR
Eq VkPeerMemoryFeatureFlagsKHR
-> (VkPeerMemoryFeatureFlagsKHR
    -> VkPeerMemoryFeatureFlagsKHR -> Ordering)
-> (VkPeerMemoryFeatureFlagsKHR
    -> VkPeerMemoryFeatureFlagsKHR -> Bool)
-> (VkPeerMemoryFeatureFlagsKHR
    -> VkPeerMemoryFeatureFlagsKHR -> Bool)
-> (VkPeerMemoryFeatureFlagsKHR
    -> VkPeerMemoryFeatureFlagsKHR -> Bool)
-> (VkPeerMemoryFeatureFlagsKHR
    -> VkPeerMemoryFeatureFlagsKHR -> Bool)
-> (VkPeerMemoryFeatureFlagsKHR
    -> VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR)
-> (VkPeerMemoryFeatureFlagsKHR
    -> VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR)
-> Ord VkPeerMemoryFeatureFlagsKHR
VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR -> Bool
VkPeerMemoryFeatureFlagsKHR
-> VkPeerMemoryFeatureFlagsKHR -> Ordering
VkPeerMemoryFeatureFlagsKHR
-> VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: VkPeerMemoryFeatureFlagsKHR
-> VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR
$cmin :: VkPeerMemoryFeatureFlagsKHR
-> VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR
max :: VkPeerMemoryFeatureFlagsKHR
-> VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR
$cmax :: VkPeerMemoryFeatureFlagsKHR
-> VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR
>= :: VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR -> Bool
$c>= :: VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR -> Bool
> :: VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR -> Bool
$c> :: VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR -> Bool
<= :: VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR -> Bool
$c<= :: VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR -> Bool
< :: VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR -> Bool
$c< :: VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR -> Bool
compare :: VkPeerMemoryFeatureFlagsKHR
-> VkPeerMemoryFeatureFlagsKHR -> Ordering
$ccompare :: VkPeerMemoryFeatureFlagsKHR
-> VkPeerMemoryFeatureFlagsKHR -> Ordering
Ord, Int -> VkPeerMemoryFeatureFlagsKHR
VkPeerMemoryFeatureFlagsKHR -> Int
VkPeerMemoryFeatureFlagsKHR -> [VkPeerMemoryFeatureFlagsKHR]
VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR
VkPeerMemoryFeatureFlagsKHR
-> VkPeerMemoryFeatureFlagsKHR -> [VkPeerMemoryFeatureFlagsKHR]
VkPeerMemoryFeatureFlagsKHR
-> VkPeerMemoryFeatureFlagsKHR
-> VkPeerMemoryFeatureFlagsKHR
-> [VkPeerMemoryFeatureFlagsKHR]
(VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR)
-> (VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR)
-> (Int -> VkPeerMemoryFeatureFlagsKHR)
-> (VkPeerMemoryFeatureFlagsKHR -> Int)
-> (VkPeerMemoryFeatureFlagsKHR -> [VkPeerMemoryFeatureFlagsKHR])
-> (VkPeerMemoryFeatureFlagsKHR
    -> VkPeerMemoryFeatureFlagsKHR -> [VkPeerMemoryFeatureFlagsKHR])
-> (VkPeerMemoryFeatureFlagsKHR
    -> VkPeerMemoryFeatureFlagsKHR -> [VkPeerMemoryFeatureFlagsKHR])
-> (VkPeerMemoryFeatureFlagsKHR
    -> VkPeerMemoryFeatureFlagsKHR
    -> VkPeerMemoryFeatureFlagsKHR
    -> [VkPeerMemoryFeatureFlagsKHR])
-> Enum VkPeerMemoryFeatureFlagsKHR
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: VkPeerMemoryFeatureFlagsKHR
-> VkPeerMemoryFeatureFlagsKHR
-> VkPeerMemoryFeatureFlagsKHR
-> [VkPeerMemoryFeatureFlagsKHR]
$cenumFromThenTo :: VkPeerMemoryFeatureFlagsKHR
-> VkPeerMemoryFeatureFlagsKHR
-> VkPeerMemoryFeatureFlagsKHR
-> [VkPeerMemoryFeatureFlagsKHR]
enumFromTo :: VkPeerMemoryFeatureFlagsKHR
-> VkPeerMemoryFeatureFlagsKHR -> [VkPeerMemoryFeatureFlagsKHR]
$cenumFromTo :: VkPeerMemoryFeatureFlagsKHR
-> VkPeerMemoryFeatureFlagsKHR -> [VkPeerMemoryFeatureFlagsKHR]
enumFromThen :: VkPeerMemoryFeatureFlagsKHR
-> VkPeerMemoryFeatureFlagsKHR -> [VkPeerMemoryFeatureFlagsKHR]
$cenumFromThen :: VkPeerMemoryFeatureFlagsKHR
-> VkPeerMemoryFeatureFlagsKHR -> [VkPeerMemoryFeatureFlagsKHR]
enumFrom :: VkPeerMemoryFeatureFlagsKHR -> [VkPeerMemoryFeatureFlagsKHR]
$cenumFrom :: VkPeerMemoryFeatureFlagsKHR -> [VkPeerMemoryFeatureFlagsKHR]
fromEnum :: VkPeerMemoryFeatureFlagsKHR -> Int
$cfromEnum :: VkPeerMemoryFeatureFlagsKHR -> Int
toEnum :: Int -> VkPeerMemoryFeatureFlagsKHR
$ctoEnum :: Int -> VkPeerMemoryFeatureFlagsKHR
pred :: VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR
$cpred :: VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR
succ :: VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR
$csucc :: VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR
Enum, Eq VkPeerMemoryFeatureFlagsKHR
VkPeerMemoryFeatureFlagsKHR
Eq VkPeerMemoryFeatureFlagsKHR
-> (VkPeerMemoryFeatureFlagsKHR
    -> VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR)
-> (VkPeerMemoryFeatureFlagsKHR
    -> VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR)
-> (VkPeerMemoryFeatureFlagsKHR
    -> VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR)
-> (VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR)
-> (VkPeerMemoryFeatureFlagsKHR
    -> Int -> VkPeerMemoryFeatureFlagsKHR)
-> (VkPeerMemoryFeatureFlagsKHR
    -> Int -> VkPeerMemoryFeatureFlagsKHR)
-> VkPeerMemoryFeatureFlagsKHR
-> (Int -> VkPeerMemoryFeatureFlagsKHR)
-> (VkPeerMemoryFeatureFlagsKHR
    -> Int -> VkPeerMemoryFeatureFlagsKHR)
-> (VkPeerMemoryFeatureFlagsKHR
    -> Int -> VkPeerMemoryFeatureFlagsKHR)
-> (VkPeerMemoryFeatureFlagsKHR
    -> Int -> VkPeerMemoryFeatureFlagsKHR)
-> (VkPeerMemoryFeatureFlagsKHR -> Int -> Bool)
-> (VkPeerMemoryFeatureFlagsKHR -> Maybe Int)
-> (VkPeerMemoryFeatureFlagsKHR -> Int)
-> (VkPeerMemoryFeatureFlagsKHR -> Bool)
-> (VkPeerMemoryFeatureFlagsKHR
    -> Int -> VkPeerMemoryFeatureFlagsKHR)
-> (VkPeerMemoryFeatureFlagsKHR
    -> Int -> VkPeerMemoryFeatureFlagsKHR)
-> (VkPeerMemoryFeatureFlagsKHR
    -> Int -> VkPeerMemoryFeatureFlagsKHR)
-> (VkPeerMemoryFeatureFlagsKHR
    -> Int -> VkPeerMemoryFeatureFlagsKHR)
-> (VkPeerMemoryFeatureFlagsKHR
    -> Int -> VkPeerMemoryFeatureFlagsKHR)
-> (VkPeerMemoryFeatureFlagsKHR
    -> Int -> VkPeerMemoryFeatureFlagsKHR)
-> (VkPeerMemoryFeatureFlagsKHR -> Int)
-> Bits VkPeerMemoryFeatureFlagsKHR
Int -> VkPeerMemoryFeatureFlagsKHR
VkPeerMemoryFeatureFlagsKHR -> Bool
VkPeerMemoryFeatureFlagsKHR -> Int
VkPeerMemoryFeatureFlagsKHR -> Maybe Int
VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR
VkPeerMemoryFeatureFlagsKHR -> Int -> Bool
VkPeerMemoryFeatureFlagsKHR -> Int -> VkPeerMemoryFeatureFlagsKHR
VkPeerMemoryFeatureFlagsKHR
-> VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR
forall a.
Eq a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
popCount :: VkPeerMemoryFeatureFlagsKHR -> Int
$cpopCount :: VkPeerMemoryFeatureFlagsKHR -> Int
rotateR :: VkPeerMemoryFeatureFlagsKHR -> Int -> VkPeerMemoryFeatureFlagsKHR
$crotateR :: VkPeerMemoryFeatureFlagsKHR -> Int -> VkPeerMemoryFeatureFlagsKHR
rotateL :: VkPeerMemoryFeatureFlagsKHR -> Int -> VkPeerMemoryFeatureFlagsKHR
$crotateL :: VkPeerMemoryFeatureFlagsKHR -> Int -> VkPeerMemoryFeatureFlagsKHR
unsafeShiftR :: VkPeerMemoryFeatureFlagsKHR -> Int -> VkPeerMemoryFeatureFlagsKHR
$cunsafeShiftR :: VkPeerMemoryFeatureFlagsKHR -> Int -> VkPeerMemoryFeatureFlagsKHR
shiftR :: VkPeerMemoryFeatureFlagsKHR -> Int -> VkPeerMemoryFeatureFlagsKHR
$cshiftR :: VkPeerMemoryFeatureFlagsKHR -> Int -> VkPeerMemoryFeatureFlagsKHR
unsafeShiftL :: VkPeerMemoryFeatureFlagsKHR -> Int -> VkPeerMemoryFeatureFlagsKHR
$cunsafeShiftL :: VkPeerMemoryFeatureFlagsKHR -> Int -> VkPeerMemoryFeatureFlagsKHR
shiftL :: VkPeerMemoryFeatureFlagsKHR -> Int -> VkPeerMemoryFeatureFlagsKHR
$cshiftL :: VkPeerMemoryFeatureFlagsKHR -> Int -> VkPeerMemoryFeatureFlagsKHR
isSigned :: VkPeerMemoryFeatureFlagsKHR -> Bool
$cisSigned :: VkPeerMemoryFeatureFlagsKHR -> Bool
bitSize :: VkPeerMemoryFeatureFlagsKHR -> Int
$cbitSize :: VkPeerMemoryFeatureFlagsKHR -> Int
bitSizeMaybe :: VkPeerMemoryFeatureFlagsKHR -> Maybe Int
$cbitSizeMaybe :: VkPeerMemoryFeatureFlagsKHR -> Maybe Int
testBit :: VkPeerMemoryFeatureFlagsKHR -> Int -> Bool
$ctestBit :: VkPeerMemoryFeatureFlagsKHR -> Int -> Bool
complementBit :: VkPeerMemoryFeatureFlagsKHR -> Int -> VkPeerMemoryFeatureFlagsKHR
$ccomplementBit :: VkPeerMemoryFeatureFlagsKHR -> Int -> VkPeerMemoryFeatureFlagsKHR
clearBit :: VkPeerMemoryFeatureFlagsKHR -> Int -> VkPeerMemoryFeatureFlagsKHR
$cclearBit :: VkPeerMemoryFeatureFlagsKHR -> Int -> VkPeerMemoryFeatureFlagsKHR
setBit :: VkPeerMemoryFeatureFlagsKHR -> Int -> VkPeerMemoryFeatureFlagsKHR
$csetBit :: VkPeerMemoryFeatureFlagsKHR -> Int -> VkPeerMemoryFeatureFlagsKHR
bit :: Int -> VkPeerMemoryFeatureFlagsKHR
$cbit :: Int -> VkPeerMemoryFeatureFlagsKHR
zeroBits :: VkPeerMemoryFeatureFlagsKHR
$czeroBits :: VkPeerMemoryFeatureFlagsKHR
rotate :: VkPeerMemoryFeatureFlagsKHR -> Int -> VkPeerMemoryFeatureFlagsKHR
$crotate :: VkPeerMemoryFeatureFlagsKHR -> Int -> VkPeerMemoryFeatureFlagsKHR
shift :: VkPeerMemoryFeatureFlagsKHR -> Int -> VkPeerMemoryFeatureFlagsKHR
$cshift :: VkPeerMemoryFeatureFlagsKHR -> Int -> VkPeerMemoryFeatureFlagsKHR
complement :: VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR
$ccomplement :: VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR
xor :: VkPeerMemoryFeatureFlagsKHR
-> VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR
$cxor :: VkPeerMemoryFeatureFlagsKHR
-> VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR
.|. :: VkPeerMemoryFeatureFlagsKHR
-> VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR
$c.|. :: VkPeerMemoryFeatureFlagsKHR
-> VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR
.&. :: VkPeerMemoryFeatureFlagsKHR
-> VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR
$c.&. :: VkPeerMemoryFeatureFlagsKHR
-> VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR
Bits, Bits VkPeerMemoryFeatureFlagsKHR
Bits VkPeerMemoryFeatureFlagsKHR
-> (VkPeerMemoryFeatureFlagsKHR -> Int)
-> (VkPeerMemoryFeatureFlagsKHR -> Int)
-> (VkPeerMemoryFeatureFlagsKHR -> Int)
-> FiniteBits VkPeerMemoryFeatureFlagsKHR
VkPeerMemoryFeatureFlagsKHR -> Int
forall b.
Bits b -> (b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
countTrailingZeros :: VkPeerMemoryFeatureFlagsKHR -> Int
$ccountTrailingZeros :: VkPeerMemoryFeatureFlagsKHR -> Int
countLeadingZeros :: VkPeerMemoryFeatureFlagsKHR -> Int
$ccountLeadingZeros :: VkPeerMemoryFeatureFlagsKHR -> Int
finiteBitSize :: VkPeerMemoryFeatureFlagsKHR -> Int
$cfiniteBitSize :: VkPeerMemoryFeatureFlagsKHR -> Int
FiniteBits, Ptr VkPeerMemoryFeatureFlagsKHR -> IO VkPeerMemoryFeatureFlagsKHR
Ptr VkPeerMemoryFeatureFlagsKHR
-> Int -> IO VkPeerMemoryFeatureFlagsKHR
Ptr VkPeerMemoryFeatureFlagsKHR
-> Int -> VkPeerMemoryFeatureFlagsKHR -> IO ()
Ptr VkPeerMemoryFeatureFlagsKHR
-> VkPeerMemoryFeatureFlagsKHR -> IO ()
VkPeerMemoryFeatureFlagsKHR -> Int
(VkPeerMemoryFeatureFlagsKHR -> Int)
-> (VkPeerMemoryFeatureFlagsKHR -> Int)
-> (Ptr VkPeerMemoryFeatureFlagsKHR
    -> Int -> IO VkPeerMemoryFeatureFlagsKHR)
-> (Ptr VkPeerMemoryFeatureFlagsKHR
    -> Int -> VkPeerMemoryFeatureFlagsKHR -> IO ())
-> (forall b. Ptr b -> Int -> IO VkPeerMemoryFeatureFlagsKHR)
-> (forall b. Ptr b -> Int -> VkPeerMemoryFeatureFlagsKHR -> IO ())
-> (Ptr VkPeerMemoryFeatureFlagsKHR
    -> IO VkPeerMemoryFeatureFlagsKHR)
-> (Ptr VkPeerMemoryFeatureFlagsKHR
    -> VkPeerMemoryFeatureFlagsKHR -> IO ())
-> Storable VkPeerMemoryFeatureFlagsKHR
forall b. Ptr b -> Int -> IO VkPeerMemoryFeatureFlagsKHR
forall b. Ptr b -> Int -> VkPeerMemoryFeatureFlagsKHR -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr VkPeerMemoryFeatureFlagsKHR
-> VkPeerMemoryFeatureFlagsKHR -> IO ()
$cpoke :: Ptr VkPeerMemoryFeatureFlagsKHR
-> VkPeerMemoryFeatureFlagsKHR -> IO ()
peek :: Ptr VkPeerMemoryFeatureFlagsKHR -> IO VkPeerMemoryFeatureFlagsKHR
$cpeek :: Ptr VkPeerMemoryFeatureFlagsKHR -> IO VkPeerMemoryFeatureFlagsKHR
pokeByteOff :: forall b. Ptr b -> Int -> VkPeerMemoryFeatureFlagsKHR -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> VkPeerMemoryFeatureFlagsKHR -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO VkPeerMemoryFeatureFlagsKHR
$cpeekByteOff :: forall b. Ptr b -> Int -> IO VkPeerMemoryFeatureFlagsKHR
pokeElemOff :: Ptr VkPeerMemoryFeatureFlagsKHR
-> Int -> VkPeerMemoryFeatureFlagsKHR -> IO ()
$cpokeElemOff :: Ptr VkPeerMemoryFeatureFlagsKHR
-> Int -> VkPeerMemoryFeatureFlagsKHR -> IO ()
peekElemOff :: Ptr VkPeerMemoryFeatureFlagsKHR
-> Int -> IO VkPeerMemoryFeatureFlagsKHR
$cpeekElemOff :: Ptr VkPeerMemoryFeatureFlagsKHR
-> Int -> IO VkPeerMemoryFeatureFlagsKHR
alignment :: VkPeerMemoryFeatureFlagsKHR -> Int
$calignment :: VkPeerMemoryFeatureFlagsKHR -> Int
sizeOf :: VkPeerMemoryFeatureFlagsKHR -> Int
$csizeOf :: VkPeerMemoryFeatureFlagsKHR -> Int
Storable)

instance Show VkPeerMemoryFeatureFlagsKHR where
    {-# INLINE showsPrec #-}
    showsPrec :: Int -> VkPeerMemoryFeatureFlagsKHR -> ShowS
showsPrec = (Int -> VkFlags -> ShowS)
-> Int -> VkPeerMemoryFeatureFlagsKHR -> ShowS
coerce (Int -> VkFlags -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec :: Int -> VkFlags -> ShowS)

instance Read VkPeerMemoryFeatureFlagsKHR where
    {-# INLINE readsPrec #-}
    readsPrec :: Int -> ReadS VkPeerMemoryFeatureFlagsKHR
readsPrec = (Int -> ReadS VkFlags) -> Int -> ReadS VkPeerMemoryFeatureFlagsKHR
coerce (Int -> ReadS VkFlags
forall a. Read a => Int -> ReadS a
readsPrec :: Int -> ReadS VkFlags)

newtype VkPipelineColorBlendStateCreateFlags = VkPipelineColorBlendStateCreateFlags VkFlags
                                               deriving (VkPipelineColorBlendStateCreateFlags
-> VkPipelineColorBlendStateCreateFlags -> Bool
(VkPipelineColorBlendStateCreateFlags
 -> VkPipelineColorBlendStateCreateFlags -> Bool)
-> (VkPipelineColorBlendStateCreateFlags
    -> VkPipelineColorBlendStateCreateFlags -> Bool)
-> Eq VkPipelineColorBlendStateCreateFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VkPipelineColorBlendStateCreateFlags
-> VkPipelineColorBlendStateCreateFlags -> Bool
$c/= :: VkPipelineColorBlendStateCreateFlags
-> VkPipelineColorBlendStateCreateFlags -> Bool
== :: VkPipelineColorBlendStateCreateFlags
-> VkPipelineColorBlendStateCreateFlags -> Bool
$c== :: VkPipelineColorBlendStateCreateFlags
-> VkPipelineColorBlendStateCreateFlags -> Bool
Eq, Eq VkPipelineColorBlendStateCreateFlags
Eq VkPipelineColorBlendStateCreateFlags
-> (VkPipelineColorBlendStateCreateFlags
    -> VkPipelineColorBlendStateCreateFlags -> Ordering)
-> (VkPipelineColorBlendStateCreateFlags
    -> VkPipelineColorBlendStateCreateFlags -> Bool)
-> (VkPipelineColorBlendStateCreateFlags
    -> VkPipelineColorBlendStateCreateFlags -> Bool)
-> (VkPipelineColorBlendStateCreateFlags
    -> VkPipelineColorBlendStateCreateFlags -> Bool)
-> (VkPipelineColorBlendStateCreateFlags
    -> VkPipelineColorBlendStateCreateFlags -> Bool)
-> (VkPipelineColorBlendStateCreateFlags
    -> VkPipelineColorBlendStateCreateFlags
    -> VkPipelineColorBlendStateCreateFlags)
-> (VkPipelineColorBlendStateCreateFlags
    -> VkPipelineColorBlendStateCreateFlags
    -> VkPipelineColorBlendStateCreateFlags)
-> Ord VkPipelineColorBlendStateCreateFlags
VkPipelineColorBlendStateCreateFlags
-> VkPipelineColorBlendStateCreateFlags -> Bool
VkPipelineColorBlendStateCreateFlags
-> VkPipelineColorBlendStateCreateFlags -> Ordering
VkPipelineColorBlendStateCreateFlags
-> VkPipelineColorBlendStateCreateFlags
-> VkPipelineColorBlendStateCreateFlags
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: VkPipelineColorBlendStateCreateFlags
-> VkPipelineColorBlendStateCreateFlags
-> VkPipelineColorBlendStateCreateFlags
$cmin :: VkPipelineColorBlendStateCreateFlags
-> VkPipelineColorBlendStateCreateFlags
-> VkPipelineColorBlendStateCreateFlags
max :: VkPipelineColorBlendStateCreateFlags
-> VkPipelineColorBlendStateCreateFlags
-> VkPipelineColorBlendStateCreateFlags
$cmax :: VkPipelineColorBlendStateCreateFlags
-> VkPipelineColorBlendStateCreateFlags
-> VkPipelineColorBlendStateCreateFlags
>= :: VkPipelineColorBlendStateCreateFlags
-> VkPipelineColorBlendStateCreateFlags -> Bool
$c>= :: VkPipelineColorBlendStateCreateFlags
-> VkPipelineColorBlendStateCreateFlags -> Bool
> :: VkPipelineColorBlendStateCreateFlags
-> VkPipelineColorBlendStateCreateFlags -> Bool
$c> :: VkPipelineColorBlendStateCreateFlags
-> VkPipelineColorBlendStateCreateFlags -> Bool
<= :: VkPipelineColorBlendStateCreateFlags
-> VkPipelineColorBlendStateCreateFlags -> Bool
$c<= :: VkPipelineColorBlendStateCreateFlags
-> VkPipelineColorBlendStateCreateFlags -> Bool
< :: VkPipelineColorBlendStateCreateFlags
-> VkPipelineColorBlendStateCreateFlags -> Bool
$c< :: VkPipelineColorBlendStateCreateFlags
-> VkPipelineColorBlendStateCreateFlags -> Bool
compare :: VkPipelineColorBlendStateCreateFlags
-> VkPipelineColorBlendStateCreateFlags -> Ordering
$ccompare :: VkPipelineColorBlendStateCreateFlags
-> VkPipelineColorBlendStateCreateFlags -> Ordering
Ord, Int -> VkPipelineColorBlendStateCreateFlags
VkPipelineColorBlendStateCreateFlags -> Int
VkPipelineColorBlendStateCreateFlags
-> [VkPipelineColorBlendStateCreateFlags]
VkPipelineColorBlendStateCreateFlags
-> VkPipelineColorBlendStateCreateFlags
VkPipelineColorBlendStateCreateFlags
-> VkPipelineColorBlendStateCreateFlags
-> [VkPipelineColorBlendStateCreateFlags]
VkPipelineColorBlendStateCreateFlags
-> VkPipelineColorBlendStateCreateFlags
-> VkPipelineColorBlendStateCreateFlags
-> [VkPipelineColorBlendStateCreateFlags]
(VkPipelineColorBlendStateCreateFlags
 -> VkPipelineColorBlendStateCreateFlags)
-> (VkPipelineColorBlendStateCreateFlags
    -> VkPipelineColorBlendStateCreateFlags)
-> (Int -> VkPipelineColorBlendStateCreateFlags)
-> (VkPipelineColorBlendStateCreateFlags -> Int)
-> (VkPipelineColorBlendStateCreateFlags
    -> [VkPipelineColorBlendStateCreateFlags])
-> (VkPipelineColorBlendStateCreateFlags
    -> VkPipelineColorBlendStateCreateFlags
    -> [VkPipelineColorBlendStateCreateFlags])
-> (VkPipelineColorBlendStateCreateFlags
    -> VkPipelineColorBlendStateCreateFlags
    -> [VkPipelineColorBlendStateCreateFlags])
-> (VkPipelineColorBlendStateCreateFlags
    -> VkPipelineColorBlendStateCreateFlags
    -> VkPipelineColorBlendStateCreateFlags
    -> [VkPipelineColorBlendStateCreateFlags])
-> Enum VkPipelineColorBlendStateCreateFlags
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: VkPipelineColorBlendStateCreateFlags
-> VkPipelineColorBlendStateCreateFlags
-> VkPipelineColorBlendStateCreateFlags
-> [VkPipelineColorBlendStateCreateFlags]
$cenumFromThenTo :: VkPipelineColorBlendStateCreateFlags
-> VkPipelineColorBlendStateCreateFlags
-> VkPipelineColorBlendStateCreateFlags
-> [VkPipelineColorBlendStateCreateFlags]
enumFromTo :: VkPipelineColorBlendStateCreateFlags
-> VkPipelineColorBlendStateCreateFlags
-> [VkPipelineColorBlendStateCreateFlags]
$cenumFromTo :: VkPipelineColorBlendStateCreateFlags
-> VkPipelineColorBlendStateCreateFlags
-> [VkPipelineColorBlendStateCreateFlags]
enumFromThen :: VkPipelineColorBlendStateCreateFlags
-> VkPipelineColorBlendStateCreateFlags
-> [VkPipelineColorBlendStateCreateFlags]
$cenumFromThen :: VkPipelineColorBlendStateCreateFlags
-> VkPipelineColorBlendStateCreateFlags
-> [VkPipelineColorBlendStateCreateFlags]
enumFrom :: VkPipelineColorBlendStateCreateFlags
-> [VkPipelineColorBlendStateCreateFlags]
$cenumFrom :: VkPipelineColorBlendStateCreateFlags
-> [VkPipelineColorBlendStateCreateFlags]
fromEnum :: VkPipelineColorBlendStateCreateFlags -> Int
$cfromEnum :: VkPipelineColorBlendStateCreateFlags -> Int
toEnum :: Int -> VkPipelineColorBlendStateCreateFlags
$ctoEnum :: Int -> VkPipelineColorBlendStateCreateFlags
pred :: VkPipelineColorBlendStateCreateFlags
-> VkPipelineColorBlendStateCreateFlags
$cpred :: VkPipelineColorBlendStateCreateFlags
-> VkPipelineColorBlendStateCreateFlags
succ :: VkPipelineColorBlendStateCreateFlags
-> VkPipelineColorBlendStateCreateFlags
$csucc :: VkPipelineColorBlendStateCreateFlags
-> VkPipelineColorBlendStateCreateFlags
Enum, Eq VkPipelineColorBlendStateCreateFlags
VkPipelineColorBlendStateCreateFlags
Eq VkPipelineColorBlendStateCreateFlags
-> (VkPipelineColorBlendStateCreateFlags
    -> VkPipelineColorBlendStateCreateFlags
    -> VkPipelineColorBlendStateCreateFlags)
-> (VkPipelineColorBlendStateCreateFlags
    -> VkPipelineColorBlendStateCreateFlags
    -> VkPipelineColorBlendStateCreateFlags)
-> (VkPipelineColorBlendStateCreateFlags
    -> VkPipelineColorBlendStateCreateFlags
    -> VkPipelineColorBlendStateCreateFlags)
-> (VkPipelineColorBlendStateCreateFlags
    -> VkPipelineColorBlendStateCreateFlags)
-> (VkPipelineColorBlendStateCreateFlags
    -> Int -> VkPipelineColorBlendStateCreateFlags)
-> (VkPipelineColorBlendStateCreateFlags
    -> Int -> VkPipelineColorBlendStateCreateFlags)
-> VkPipelineColorBlendStateCreateFlags
-> (Int -> VkPipelineColorBlendStateCreateFlags)
-> (VkPipelineColorBlendStateCreateFlags
    -> Int -> VkPipelineColorBlendStateCreateFlags)
-> (VkPipelineColorBlendStateCreateFlags
    -> Int -> VkPipelineColorBlendStateCreateFlags)
-> (VkPipelineColorBlendStateCreateFlags
    -> Int -> VkPipelineColorBlendStateCreateFlags)
-> (VkPipelineColorBlendStateCreateFlags -> Int -> Bool)
-> (VkPipelineColorBlendStateCreateFlags -> Maybe Int)
-> (VkPipelineColorBlendStateCreateFlags -> Int)
-> (VkPipelineColorBlendStateCreateFlags -> Bool)
-> (VkPipelineColorBlendStateCreateFlags
    -> Int -> VkPipelineColorBlendStateCreateFlags)
-> (VkPipelineColorBlendStateCreateFlags
    -> Int -> VkPipelineColorBlendStateCreateFlags)
-> (VkPipelineColorBlendStateCreateFlags
    -> Int -> VkPipelineColorBlendStateCreateFlags)
-> (VkPipelineColorBlendStateCreateFlags
    -> Int -> VkPipelineColorBlendStateCreateFlags)
-> (VkPipelineColorBlendStateCreateFlags
    -> Int -> VkPipelineColorBlendStateCreateFlags)
-> (VkPipelineColorBlendStateCreateFlags
    -> Int -> VkPipelineColorBlendStateCreateFlags)
-> (VkPipelineColorBlendStateCreateFlags -> Int)
-> Bits VkPipelineColorBlendStateCreateFlags
Int -> VkPipelineColorBlendStateCreateFlags
VkPipelineColorBlendStateCreateFlags -> Bool
VkPipelineColorBlendStateCreateFlags -> Int
VkPipelineColorBlendStateCreateFlags -> Maybe Int
VkPipelineColorBlendStateCreateFlags
-> VkPipelineColorBlendStateCreateFlags
VkPipelineColorBlendStateCreateFlags -> Int -> Bool
VkPipelineColorBlendStateCreateFlags
-> Int -> VkPipelineColorBlendStateCreateFlags
VkPipelineColorBlendStateCreateFlags
-> VkPipelineColorBlendStateCreateFlags
-> VkPipelineColorBlendStateCreateFlags
forall a.
Eq a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
popCount :: VkPipelineColorBlendStateCreateFlags -> Int
$cpopCount :: VkPipelineColorBlendStateCreateFlags -> Int
rotateR :: VkPipelineColorBlendStateCreateFlags
-> Int -> VkPipelineColorBlendStateCreateFlags
$crotateR :: VkPipelineColorBlendStateCreateFlags
-> Int -> VkPipelineColorBlendStateCreateFlags
rotateL :: VkPipelineColorBlendStateCreateFlags
-> Int -> VkPipelineColorBlendStateCreateFlags
$crotateL :: VkPipelineColorBlendStateCreateFlags
-> Int -> VkPipelineColorBlendStateCreateFlags
unsafeShiftR :: VkPipelineColorBlendStateCreateFlags
-> Int -> VkPipelineColorBlendStateCreateFlags
$cunsafeShiftR :: VkPipelineColorBlendStateCreateFlags
-> Int -> VkPipelineColorBlendStateCreateFlags
shiftR :: VkPipelineColorBlendStateCreateFlags
-> Int -> VkPipelineColorBlendStateCreateFlags
$cshiftR :: VkPipelineColorBlendStateCreateFlags
-> Int -> VkPipelineColorBlendStateCreateFlags
unsafeShiftL :: VkPipelineColorBlendStateCreateFlags
-> Int -> VkPipelineColorBlendStateCreateFlags
$cunsafeShiftL :: VkPipelineColorBlendStateCreateFlags
-> Int -> VkPipelineColorBlendStateCreateFlags
shiftL :: VkPipelineColorBlendStateCreateFlags
-> Int -> VkPipelineColorBlendStateCreateFlags
$cshiftL :: VkPipelineColorBlendStateCreateFlags
-> Int -> VkPipelineColorBlendStateCreateFlags
isSigned :: VkPipelineColorBlendStateCreateFlags -> Bool
$cisSigned :: VkPipelineColorBlendStateCreateFlags -> Bool
bitSize :: VkPipelineColorBlendStateCreateFlags -> Int
$cbitSize :: VkPipelineColorBlendStateCreateFlags -> Int
bitSizeMaybe :: VkPipelineColorBlendStateCreateFlags -> Maybe Int
$cbitSizeMaybe :: VkPipelineColorBlendStateCreateFlags -> Maybe Int
testBit :: VkPipelineColorBlendStateCreateFlags -> Int -> Bool
$ctestBit :: VkPipelineColorBlendStateCreateFlags -> Int -> Bool
complementBit :: VkPipelineColorBlendStateCreateFlags
-> Int -> VkPipelineColorBlendStateCreateFlags
$ccomplementBit :: VkPipelineColorBlendStateCreateFlags
-> Int -> VkPipelineColorBlendStateCreateFlags
clearBit :: VkPipelineColorBlendStateCreateFlags
-> Int -> VkPipelineColorBlendStateCreateFlags
$cclearBit :: VkPipelineColorBlendStateCreateFlags
-> Int -> VkPipelineColorBlendStateCreateFlags
setBit :: VkPipelineColorBlendStateCreateFlags
-> Int -> VkPipelineColorBlendStateCreateFlags
$csetBit :: VkPipelineColorBlendStateCreateFlags
-> Int -> VkPipelineColorBlendStateCreateFlags
bit :: Int -> VkPipelineColorBlendStateCreateFlags
$cbit :: Int -> VkPipelineColorBlendStateCreateFlags
zeroBits :: VkPipelineColorBlendStateCreateFlags
$czeroBits :: VkPipelineColorBlendStateCreateFlags
rotate :: VkPipelineColorBlendStateCreateFlags
-> Int -> VkPipelineColorBlendStateCreateFlags
$crotate :: VkPipelineColorBlendStateCreateFlags
-> Int -> VkPipelineColorBlendStateCreateFlags
shift :: VkPipelineColorBlendStateCreateFlags
-> Int -> VkPipelineColorBlendStateCreateFlags
$cshift :: VkPipelineColorBlendStateCreateFlags
-> Int -> VkPipelineColorBlendStateCreateFlags
complement :: VkPipelineColorBlendStateCreateFlags
-> VkPipelineColorBlendStateCreateFlags
$ccomplement :: VkPipelineColorBlendStateCreateFlags
-> VkPipelineColorBlendStateCreateFlags
xor :: VkPipelineColorBlendStateCreateFlags
-> VkPipelineColorBlendStateCreateFlags
-> VkPipelineColorBlendStateCreateFlags
$cxor :: VkPipelineColorBlendStateCreateFlags
-> VkPipelineColorBlendStateCreateFlags
-> VkPipelineColorBlendStateCreateFlags
.|. :: VkPipelineColorBlendStateCreateFlags
-> VkPipelineColorBlendStateCreateFlags
-> VkPipelineColorBlendStateCreateFlags
$c.|. :: VkPipelineColorBlendStateCreateFlags
-> VkPipelineColorBlendStateCreateFlags
-> VkPipelineColorBlendStateCreateFlags
.&. :: VkPipelineColorBlendStateCreateFlags
-> VkPipelineColorBlendStateCreateFlags
-> VkPipelineColorBlendStateCreateFlags
$c.&. :: VkPipelineColorBlendStateCreateFlags
-> VkPipelineColorBlendStateCreateFlags
-> VkPipelineColorBlendStateCreateFlags
Bits, Bits VkPipelineColorBlendStateCreateFlags
Bits VkPipelineColorBlendStateCreateFlags
-> (VkPipelineColorBlendStateCreateFlags -> Int)
-> (VkPipelineColorBlendStateCreateFlags -> Int)
-> (VkPipelineColorBlendStateCreateFlags -> Int)
-> FiniteBits VkPipelineColorBlendStateCreateFlags
VkPipelineColorBlendStateCreateFlags -> Int
forall b.
Bits b -> (b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
countTrailingZeros :: VkPipelineColorBlendStateCreateFlags -> Int
$ccountTrailingZeros :: VkPipelineColorBlendStateCreateFlags -> Int
countLeadingZeros :: VkPipelineColorBlendStateCreateFlags -> Int
$ccountLeadingZeros :: VkPipelineColorBlendStateCreateFlags -> Int
finiteBitSize :: VkPipelineColorBlendStateCreateFlags -> Int
$cfiniteBitSize :: VkPipelineColorBlendStateCreateFlags -> Int
FiniteBits, Ptr VkPipelineColorBlendStateCreateFlags
-> IO VkPipelineColorBlendStateCreateFlags
Ptr VkPipelineColorBlendStateCreateFlags
-> Int -> IO VkPipelineColorBlendStateCreateFlags
Ptr VkPipelineColorBlendStateCreateFlags
-> Int -> VkPipelineColorBlendStateCreateFlags -> IO ()
Ptr VkPipelineColorBlendStateCreateFlags
-> VkPipelineColorBlendStateCreateFlags -> IO ()
VkPipelineColorBlendStateCreateFlags -> Int
(VkPipelineColorBlendStateCreateFlags -> Int)
-> (VkPipelineColorBlendStateCreateFlags -> Int)
-> (Ptr VkPipelineColorBlendStateCreateFlags
    -> Int -> IO VkPipelineColorBlendStateCreateFlags)
-> (Ptr VkPipelineColorBlendStateCreateFlags
    -> Int -> VkPipelineColorBlendStateCreateFlags -> IO ())
-> (forall b.
    Ptr b -> Int -> IO VkPipelineColorBlendStateCreateFlags)
-> (forall b.
    Ptr b -> Int -> VkPipelineColorBlendStateCreateFlags -> IO ())
-> (Ptr VkPipelineColorBlendStateCreateFlags
    -> IO VkPipelineColorBlendStateCreateFlags)
-> (Ptr VkPipelineColorBlendStateCreateFlags
    -> VkPipelineColorBlendStateCreateFlags -> IO ())
-> Storable VkPipelineColorBlendStateCreateFlags
forall b. Ptr b -> Int -> IO VkPipelineColorBlendStateCreateFlags
forall b.
Ptr b -> Int -> VkPipelineColorBlendStateCreateFlags -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr VkPipelineColorBlendStateCreateFlags
-> VkPipelineColorBlendStateCreateFlags -> IO ()
$cpoke :: Ptr VkPipelineColorBlendStateCreateFlags
-> VkPipelineColorBlendStateCreateFlags -> IO ()
peek :: Ptr VkPipelineColorBlendStateCreateFlags
-> IO VkPipelineColorBlendStateCreateFlags
$cpeek :: Ptr VkPipelineColorBlendStateCreateFlags
-> IO VkPipelineColorBlendStateCreateFlags
pokeByteOff :: forall b.
Ptr b -> Int -> VkPipelineColorBlendStateCreateFlags -> IO ()
$cpokeByteOff :: forall b.
Ptr b -> Int -> VkPipelineColorBlendStateCreateFlags -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO VkPipelineColorBlendStateCreateFlags
$cpeekByteOff :: forall b. Ptr b -> Int -> IO VkPipelineColorBlendStateCreateFlags
pokeElemOff :: Ptr VkPipelineColorBlendStateCreateFlags
-> Int -> VkPipelineColorBlendStateCreateFlags -> IO ()
$cpokeElemOff :: Ptr VkPipelineColorBlendStateCreateFlags
-> Int -> VkPipelineColorBlendStateCreateFlags -> IO ()
peekElemOff :: Ptr VkPipelineColorBlendStateCreateFlags
-> Int -> IO VkPipelineColorBlendStateCreateFlags
$cpeekElemOff :: Ptr VkPipelineColorBlendStateCreateFlags
-> Int -> IO VkPipelineColorBlendStateCreateFlags
alignment :: VkPipelineColorBlendStateCreateFlags -> Int
$calignment :: VkPipelineColorBlendStateCreateFlags -> Int
sizeOf :: VkPipelineColorBlendStateCreateFlags -> Int
$csizeOf :: VkPipelineColorBlendStateCreateFlags -> Int
Storable)

instance Show VkPipelineColorBlendStateCreateFlags where
    {-# INLINE showsPrec #-}
    showsPrec :: Int -> VkPipelineColorBlendStateCreateFlags -> ShowS
showsPrec = (Int -> VkFlags -> ShowS)
-> Int -> VkPipelineColorBlendStateCreateFlags -> ShowS
coerce (Int -> VkFlags -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec :: Int -> VkFlags -> ShowS)

instance Read VkPipelineColorBlendStateCreateFlags where
    {-# INLINE readsPrec #-}
    readsPrec :: Int -> ReadS VkPipelineColorBlendStateCreateFlags
readsPrec = (Int -> ReadS VkFlags)
-> Int -> ReadS VkPipelineColorBlendStateCreateFlags
coerce (Int -> ReadS VkFlags
forall a. Read a => Int -> ReadS a
readsPrec :: Int -> ReadS VkFlags)

newtype VkPipelineCoverageModulationStateCreateFlagsNV = VkPipelineCoverageModulationStateCreateFlagsNV VkFlags
                                                         deriving (VkPipelineCoverageModulationStateCreateFlagsNV
-> VkPipelineCoverageModulationStateCreateFlagsNV -> Bool
(VkPipelineCoverageModulationStateCreateFlagsNV
 -> VkPipelineCoverageModulationStateCreateFlagsNV -> Bool)
-> (VkPipelineCoverageModulationStateCreateFlagsNV
    -> VkPipelineCoverageModulationStateCreateFlagsNV -> Bool)
-> Eq VkPipelineCoverageModulationStateCreateFlagsNV
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VkPipelineCoverageModulationStateCreateFlagsNV
-> VkPipelineCoverageModulationStateCreateFlagsNV -> Bool
$c/= :: VkPipelineCoverageModulationStateCreateFlagsNV
-> VkPipelineCoverageModulationStateCreateFlagsNV -> Bool
== :: VkPipelineCoverageModulationStateCreateFlagsNV
-> VkPipelineCoverageModulationStateCreateFlagsNV -> Bool
$c== :: VkPipelineCoverageModulationStateCreateFlagsNV
-> VkPipelineCoverageModulationStateCreateFlagsNV -> Bool
Eq, Eq VkPipelineCoverageModulationStateCreateFlagsNV
Eq VkPipelineCoverageModulationStateCreateFlagsNV
-> (VkPipelineCoverageModulationStateCreateFlagsNV
    -> VkPipelineCoverageModulationStateCreateFlagsNV -> Ordering)
-> (VkPipelineCoverageModulationStateCreateFlagsNV
    -> VkPipelineCoverageModulationStateCreateFlagsNV -> Bool)
-> (VkPipelineCoverageModulationStateCreateFlagsNV
    -> VkPipelineCoverageModulationStateCreateFlagsNV -> Bool)
-> (VkPipelineCoverageModulationStateCreateFlagsNV
    -> VkPipelineCoverageModulationStateCreateFlagsNV -> Bool)
-> (VkPipelineCoverageModulationStateCreateFlagsNV
    -> VkPipelineCoverageModulationStateCreateFlagsNV -> Bool)
-> (VkPipelineCoverageModulationStateCreateFlagsNV
    -> VkPipelineCoverageModulationStateCreateFlagsNV
    -> VkPipelineCoverageModulationStateCreateFlagsNV)
-> (VkPipelineCoverageModulationStateCreateFlagsNV
    -> VkPipelineCoverageModulationStateCreateFlagsNV
    -> VkPipelineCoverageModulationStateCreateFlagsNV)
-> Ord VkPipelineCoverageModulationStateCreateFlagsNV
VkPipelineCoverageModulationStateCreateFlagsNV
-> VkPipelineCoverageModulationStateCreateFlagsNV -> Bool
VkPipelineCoverageModulationStateCreateFlagsNV
-> VkPipelineCoverageModulationStateCreateFlagsNV -> Ordering
VkPipelineCoverageModulationStateCreateFlagsNV
-> VkPipelineCoverageModulationStateCreateFlagsNV
-> VkPipelineCoverageModulationStateCreateFlagsNV
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: VkPipelineCoverageModulationStateCreateFlagsNV
-> VkPipelineCoverageModulationStateCreateFlagsNV
-> VkPipelineCoverageModulationStateCreateFlagsNV
$cmin :: VkPipelineCoverageModulationStateCreateFlagsNV
-> VkPipelineCoverageModulationStateCreateFlagsNV
-> VkPipelineCoverageModulationStateCreateFlagsNV
max :: VkPipelineCoverageModulationStateCreateFlagsNV
-> VkPipelineCoverageModulationStateCreateFlagsNV
-> VkPipelineCoverageModulationStateCreateFlagsNV
$cmax :: VkPipelineCoverageModulationStateCreateFlagsNV
-> VkPipelineCoverageModulationStateCreateFlagsNV
-> VkPipelineCoverageModulationStateCreateFlagsNV
>= :: VkPipelineCoverageModulationStateCreateFlagsNV
-> VkPipelineCoverageModulationStateCreateFlagsNV -> Bool
$c>= :: VkPipelineCoverageModulationStateCreateFlagsNV
-> VkPipelineCoverageModulationStateCreateFlagsNV -> Bool
> :: VkPipelineCoverageModulationStateCreateFlagsNV
-> VkPipelineCoverageModulationStateCreateFlagsNV -> Bool
$c> :: VkPipelineCoverageModulationStateCreateFlagsNV
-> VkPipelineCoverageModulationStateCreateFlagsNV -> Bool
<= :: VkPipelineCoverageModulationStateCreateFlagsNV
-> VkPipelineCoverageModulationStateCreateFlagsNV -> Bool
$c<= :: VkPipelineCoverageModulationStateCreateFlagsNV
-> VkPipelineCoverageModulationStateCreateFlagsNV -> Bool
< :: VkPipelineCoverageModulationStateCreateFlagsNV
-> VkPipelineCoverageModulationStateCreateFlagsNV -> Bool
$c< :: VkPipelineCoverageModulationStateCreateFlagsNV
-> VkPipelineCoverageModulationStateCreateFlagsNV -> Bool
compare :: VkPipelineCoverageModulationStateCreateFlagsNV
-> VkPipelineCoverageModulationStateCreateFlagsNV -> Ordering
$ccompare :: VkPipelineCoverageModulationStateCreateFlagsNV
-> VkPipelineCoverageModulationStateCreateFlagsNV -> Ordering
Ord, Int -> VkPipelineCoverageModulationStateCreateFlagsNV
VkPipelineCoverageModulationStateCreateFlagsNV -> Int
VkPipelineCoverageModulationStateCreateFlagsNV
-> [VkPipelineCoverageModulationStateCreateFlagsNV]
VkPipelineCoverageModulationStateCreateFlagsNV
-> VkPipelineCoverageModulationStateCreateFlagsNV
VkPipelineCoverageModulationStateCreateFlagsNV
-> VkPipelineCoverageModulationStateCreateFlagsNV
-> [VkPipelineCoverageModulationStateCreateFlagsNV]
VkPipelineCoverageModulationStateCreateFlagsNV
-> VkPipelineCoverageModulationStateCreateFlagsNV
-> VkPipelineCoverageModulationStateCreateFlagsNV
-> [VkPipelineCoverageModulationStateCreateFlagsNV]
(VkPipelineCoverageModulationStateCreateFlagsNV
 -> VkPipelineCoverageModulationStateCreateFlagsNV)
-> (VkPipelineCoverageModulationStateCreateFlagsNV
    -> VkPipelineCoverageModulationStateCreateFlagsNV)
-> (Int -> VkPipelineCoverageModulationStateCreateFlagsNV)
-> (VkPipelineCoverageModulationStateCreateFlagsNV -> Int)
-> (VkPipelineCoverageModulationStateCreateFlagsNV
    -> [VkPipelineCoverageModulationStateCreateFlagsNV])
-> (VkPipelineCoverageModulationStateCreateFlagsNV
    -> VkPipelineCoverageModulationStateCreateFlagsNV
    -> [VkPipelineCoverageModulationStateCreateFlagsNV])
-> (VkPipelineCoverageModulationStateCreateFlagsNV
    -> VkPipelineCoverageModulationStateCreateFlagsNV
    -> [VkPipelineCoverageModulationStateCreateFlagsNV])
-> (VkPipelineCoverageModulationStateCreateFlagsNV
    -> VkPipelineCoverageModulationStateCreateFlagsNV
    -> VkPipelineCoverageModulationStateCreateFlagsNV
    -> [VkPipelineCoverageModulationStateCreateFlagsNV])
-> Enum VkPipelineCoverageModulationStateCreateFlagsNV
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: VkPipelineCoverageModulationStateCreateFlagsNV
-> VkPipelineCoverageModulationStateCreateFlagsNV
-> VkPipelineCoverageModulationStateCreateFlagsNV
-> [VkPipelineCoverageModulationStateCreateFlagsNV]
$cenumFromThenTo :: VkPipelineCoverageModulationStateCreateFlagsNV
-> VkPipelineCoverageModulationStateCreateFlagsNV
-> VkPipelineCoverageModulationStateCreateFlagsNV
-> [VkPipelineCoverageModulationStateCreateFlagsNV]
enumFromTo :: VkPipelineCoverageModulationStateCreateFlagsNV
-> VkPipelineCoverageModulationStateCreateFlagsNV
-> [VkPipelineCoverageModulationStateCreateFlagsNV]
$cenumFromTo :: VkPipelineCoverageModulationStateCreateFlagsNV
-> VkPipelineCoverageModulationStateCreateFlagsNV
-> [VkPipelineCoverageModulationStateCreateFlagsNV]
enumFromThen :: VkPipelineCoverageModulationStateCreateFlagsNV
-> VkPipelineCoverageModulationStateCreateFlagsNV
-> [VkPipelineCoverageModulationStateCreateFlagsNV]
$cenumFromThen :: VkPipelineCoverageModulationStateCreateFlagsNV
-> VkPipelineCoverageModulationStateCreateFlagsNV
-> [VkPipelineCoverageModulationStateCreateFlagsNV]
enumFrom :: VkPipelineCoverageModulationStateCreateFlagsNV
-> [VkPipelineCoverageModulationStateCreateFlagsNV]
$cenumFrom :: VkPipelineCoverageModulationStateCreateFlagsNV
-> [VkPipelineCoverageModulationStateCreateFlagsNV]
fromEnum :: VkPipelineCoverageModulationStateCreateFlagsNV -> Int
$cfromEnum :: VkPipelineCoverageModulationStateCreateFlagsNV -> Int
toEnum :: Int -> VkPipelineCoverageModulationStateCreateFlagsNV
$ctoEnum :: Int -> VkPipelineCoverageModulationStateCreateFlagsNV
pred :: VkPipelineCoverageModulationStateCreateFlagsNV
-> VkPipelineCoverageModulationStateCreateFlagsNV
$cpred :: VkPipelineCoverageModulationStateCreateFlagsNV
-> VkPipelineCoverageModulationStateCreateFlagsNV
succ :: VkPipelineCoverageModulationStateCreateFlagsNV
-> VkPipelineCoverageModulationStateCreateFlagsNV
$csucc :: VkPipelineCoverageModulationStateCreateFlagsNV
-> VkPipelineCoverageModulationStateCreateFlagsNV
Enum, Eq VkPipelineCoverageModulationStateCreateFlagsNV
VkPipelineCoverageModulationStateCreateFlagsNV
Eq VkPipelineCoverageModulationStateCreateFlagsNV
-> (VkPipelineCoverageModulationStateCreateFlagsNV
    -> VkPipelineCoverageModulationStateCreateFlagsNV
    -> VkPipelineCoverageModulationStateCreateFlagsNV)
-> (VkPipelineCoverageModulationStateCreateFlagsNV
    -> VkPipelineCoverageModulationStateCreateFlagsNV
    -> VkPipelineCoverageModulationStateCreateFlagsNV)
-> (VkPipelineCoverageModulationStateCreateFlagsNV
    -> VkPipelineCoverageModulationStateCreateFlagsNV
    -> VkPipelineCoverageModulationStateCreateFlagsNV)
-> (VkPipelineCoverageModulationStateCreateFlagsNV
    -> VkPipelineCoverageModulationStateCreateFlagsNV)
-> (VkPipelineCoverageModulationStateCreateFlagsNV
    -> Int -> VkPipelineCoverageModulationStateCreateFlagsNV)
-> (VkPipelineCoverageModulationStateCreateFlagsNV
    -> Int -> VkPipelineCoverageModulationStateCreateFlagsNV)
-> VkPipelineCoverageModulationStateCreateFlagsNV
-> (Int -> VkPipelineCoverageModulationStateCreateFlagsNV)
-> (VkPipelineCoverageModulationStateCreateFlagsNV
    -> Int -> VkPipelineCoverageModulationStateCreateFlagsNV)
-> (VkPipelineCoverageModulationStateCreateFlagsNV
    -> Int -> VkPipelineCoverageModulationStateCreateFlagsNV)
-> (VkPipelineCoverageModulationStateCreateFlagsNV
    -> Int -> VkPipelineCoverageModulationStateCreateFlagsNV)
-> (VkPipelineCoverageModulationStateCreateFlagsNV -> Int -> Bool)
-> (VkPipelineCoverageModulationStateCreateFlagsNV -> Maybe Int)
-> (VkPipelineCoverageModulationStateCreateFlagsNV -> Int)
-> (VkPipelineCoverageModulationStateCreateFlagsNV -> Bool)
-> (VkPipelineCoverageModulationStateCreateFlagsNV
    -> Int -> VkPipelineCoverageModulationStateCreateFlagsNV)
-> (VkPipelineCoverageModulationStateCreateFlagsNV
    -> Int -> VkPipelineCoverageModulationStateCreateFlagsNV)
-> (VkPipelineCoverageModulationStateCreateFlagsNV
    -> Int -> VkPipelineCoverageModulationStateCreateFlagsNV)
-> (VkPipelineCoverageModulationStateCreateFlagsNV
    -> Int -> VkPipelineCoverageModulationStateCreateFlagsNV)
-> (VkPipelineCoverageModulationStateCreateFlagsNV
    -> Int -> VkPipelineCoverageModulationStateCreateFlagsNV)
-> (VkPipelineCoverageModulationStateCreateFlagsNV
    -> Int -> VkPipelineCoverageModulationStateCreateFlagsNV)
-> (VkPipelineCoverageModulationStateCreateFlagsNV -> Int)
-> Bits VkPipelineCoverageModulationStateCreateFlagsNV
Int -> VkPipelineCoverageModulationStateCreateFlagsNV
VkPipelineCoverageModulationStateCreateFlagsNV -> Bool
VkPipelineCoverageModulationStateCreateFlagsNV -> Int
VkPipelineCoverageModulationStateCreateFlagsNV -> Maybe Int
VkPipelineCoverageModulationStateCreateFlagsNV
-> VkPipelineCoverageModulationStateCreateFlagsNV
VkPipelineCoverageModulationStateCreateFlagsNV -> Int -> Bool
VkPipelineCoverageModulationStateCreateFlagsNV
-> Int -> VkPipelineCoverageModulationStateCreateFlagsNV
VkPipelineCoverageModulationStateCreateFlagsNV
-> VkPipelineCoverageModulationStateCreateFlagsNV
-> VkPipelineCoverageModulationStateCreateFlagsNV
forall a.
Eq a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
popCount :: VkPipelineCoverageModulationStateCreateFlagsNV -> Int
$cpopCount :: VkPipelineCoverageModulationStateCreateFlagsNV -> Int
rotateR :: VkPipelineCoverageModulationStateCreateFlagsNV
-> Int -> VkPipelineCoverageModulationStateCreateFlagsNV
$crotateR :: VkPipelineCoverageModulationStateCreateFlagsNV
-> Int -> VkPipelineCoverageModulationStateCreateFlagsNV
rotateL :: VkPipelineCoverageModulationStateCreateFlagsNV
-> Int -> VkPipelineCoverageModulationStateCreateFlagsNV
$crotateL :: VkPipelineCoverageModulationStateCreateFlagsNV
-> Int -> VkPipelineCoverageModulationStateCreateFlagsNV
unsafeShiftR :: VkPipelineCoverageModulationStateCreateFlagsNV
-> Int -> VkPipelineCoverageModulationStateCreateFlagsNV
$cunsafeShiftR :: VkPipelineCoverageModulationStateCreateFlagsNV
-> Int -> VkPipelineCoverageModulationStateCreateFlagsNV
shiftR :: VkPipelineCoverageModulationStateCreateFlagsNV
-> Int -> VkPipelineCoverageModulationStateCreateFlagsNV
$cshiftR :: VkPipelineCoverageModulationStateCreateFlagsNV
-> Int -> VkPipelineCoverageModulationStateCreateFlagsNV
unsafeShiftL :: VkPipelineCoverageModulationStateCreateFlagsNV
-> Int -> VkPipelineCoverageModulationStateCreateFlagsNV
$cunsafeShiftL :: VkPipelineCoverageModulationStateCreateFlagsNV
-> Int -> VkPipelineCoverageModulationStateCreateFlagsNV
shiftL :: VkPipelineCoverageModulationStateCreateFlagsNV
-> Int -> VkPipelineCoverageModulationStateCreateFlagsNV
$cshiftL :: VkPipelineCoverageModulationStateCreateFlagsNV
-> Int -> VkPipelineCoverageModulationStateCreateFlagsNV
isSigned :: VkPipelineCoverageModulationStateCreateFlagsNV -> Bool
$cisSigned :: VkPipelineCoverageModulationStateCreateFlagsNV -> Bool
bitSize :: VkPipelineCoverageModulationStateCreateFlagsNV -> Int
$cbitSize :: VkPipelineCoverageModulationStateCreateFlagsNV -> Int
bitSizeMaybe :: VkPipelineCoverageModulationStateCreateFlagsNV -> Maybe Int
$cbitSizeMaybe :: VkPipelineCoverageModulationStateCreateFlagsNV -> Maybe Int
testBit :: VkPipelineCoverageModulationStateCreateFlagsNV -> Int -> Bool
$ctestBit :: VkPipelineCoverageModulationStateCreateFlagsNV -> Int -> Bool
complementBit :: VkPipelineCoverageModulationStateCreateFlagsNV
-> Int -> VkPipelineCoverageModulationStateCreateFlagsNV
$ccomplementBit :: VkPipelineCoverageModulationStateCreateFlagsNV
-> Int -> VkPipelineCoverageModulationStateCreateFlagsNV
clearBit :: VkPipelineCoverageModulationStateCreateFlagsNV
-> Int -> VkPipelineCoverageModulationStateCreateFlagsNV
$cclearBit :: VkPipelineCoverageModulationStateCreateFlagsNV
-> Int -> VkPipelineCoverageModulationStateCreateFlagsNV
setBit :: VkPipelineCoverageModulationStateCreateFlagsNV
-> Int -> VkPipelineCoverageModulationStateCreateFlagsNV
$csetBit :: VkPipelineCoverageModulationStateCreateFlagsNV
-> Int -> VkPipelineCoverageModulationStateCreateFlagsNV
bit :: Int -> VkPipelineCoverageModulationStateCreateFlagsNV
$cbit :: Int -> VkPipelineCoverageModulationStateCreateFlagsNV
zeroBits :: VkPipelineCoverageModulationStateCreateFlagsNV
$czeroBits :: VkPipelineCoverageModulationStateCreateFlagsNV
rotate :: VkPipelineCoverageModulationStateCreateFlagsNV
-> Int -> VkPipelineCoverageModulationStateCreateFlagsNV
$crotate :: VkPipelineCoverageModulationStateCreateFlagsNV
-> Int -> VkPipelineCoverageModulationStateCreateFlagsNV
shift :: VkPipelineCoverageModulationStateCreateFlagsNV
-> Int -> VkPipelineCoverageModulationStateCreateFlagsNV
$cshift :: VkPipelineCoverageModulationStateCreateFlagsNV
-> Int -> VkPipelineCoverageModulationStateCreateFlagsNV
complement :: VkPipelineCoverageModulationStateCreateFlagsNV
-> VkPipelineCoverageModulationStateCreateFlagsNV
$ccomplement :: VkPipelineCoverageModulationStateCreateFlagsNV
-> VkPipelineCoverageModulationStateCreateFlagsNV
xor :: VkPipelineCoverageModulationStateCreateFlagsNV
-> VkPipelineCoverageModulationStateCreateFlagsNV
-> VkPipelineCoverageModulationStateCreateFlagsNV
$cxor :: VkPipelineCoverageModulationStateCreateFlagsNV
-> VkPipelineCoverageModulationStateCreateFlagsNV
-> VkPipelineCoverageModulationStateCreateFlagsNV
.|. :: VkPipelineCoverageModulationStateCreateFlagsNV
-> VkPipelineCoverageModulationStateCreateFlagsNV
-> VkPipelineCoverageModulationStateCreateFlagsNV
$c.|. :: VkPipelineCoverageModulationStateCreateFlagsNV
-> VkPipelineCoverageModulationStateCreateFlagsNV
-> VkPipelineCoverageModulationStateCreateFlagsNV
.&. :: VkPipelineCoverageModulationStateCreateFlagsNV
-> VkPipelineCoverageModulationStateCreateFlagsNV
-> VkPipelineCoverageModulationStateCreateFlagsNV
$c.&. :: VkPipelineCoverageModulationStateCreateFlagsNV
-> VkPipelineCoverageModulationStateCreateFlagsNV
-> VkPipelineCoverageModulationStateCreateFlagsNV
Bits, Bits VkPipelineCoverageModulationStateCreateFlagsNV
Bits VkPipelineCoverageModulationStateCreateFlagsNV
-> (VkPipelineCoverageModulationStateCreateFlagsNV -> Int)
-> (VkPipelineCoverageModulationStateCreateFlagsNV -> Int)
-> (VkPipelineCoverageModulationStateCreateFlagsNV -> Int)
-> FiniteBits VkPipelineCoverageModulationStateCreateFlagsNV
VkPipelineCoverageModulationStateCreateFlagsNV -> Int
forall b.
Bits b -> (b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
countTrailingZeros :: VkPipelineCoverageModulationStateCreateFlagsNV -> Int
$ccountTrailingZeros :: VkPipelineCoverageModulationStateCreateFlagsNV -> Int
countLeadingZeros :: VkPipelineCoverageModulationStateCreateFlagsNV -> Int
$ccountLeadingZeros :: VkPipelineCoverageModulationStateCreateFlagsNV -> Int
finiteBitSize :: VkPipelineCoverageModulationStateCreateFlagsNV -> Int
$cfiniteBitSize :: VkPipelineCoverageModulationStateCreateFlagsNV -> Int
FiniteBits,
                                                                   Ptr VkPipelineCoverageModulationStateCreateFlagsNV
-> IO VkPipelineCoverageModulationStateCreateFlagsNV
Ptr VkPipelineCoverageModulationStateCreateFlagsNV
-> Int -> IO VkPipelineCoverageModulationStateCreateFlagsNV
Ptr VkPipelineCoverageModulationStateCreateFlagsNV
-> Int -> VkPipelineCoverageModulationStateCreateFlagsNV -> IO ()
Ptr VkPipelineCoverageModulationStateCreateFlagsNV
-> VkPipelineCoverageModulationStateCreateFlagsNV -> IO ()
VkPipelineCoverageModulationStateCreateFlagsNV -> Int
(VkPipelineCoverageModulationStateCreateFlagsNV -> Int)
-> (VkPipelineCoverageModulationStateCreateFlagsNV -> Int)
-> (Ptr VkPipelineCoverageModulationStateCreateFlagsNV
    -> Int -> IO VkPipelineCoverageModulationStateCreateFlagsNV)
-> (Ptr VkPipelineCoverageModulationStateCreateFlagsNV
    -> Int -> VkPipelineCoverageModulationStateCreateFlagsNV -> IO ())
-> (forall b.
    Ptr b -> Int -> IO VkPipelineCoverageModulationStateCreateFlagsNV)
-> (forall b.
    Ptr b
    -> Int -> VkPipelineCoverageModulationStateCreateFlagsNV -> IO ())
-> (Ptr VkPipelineCoverageModulationStateCreateFlagsNV
    -> IO VkPipelineCoverageModulationStateCreateFlagsNV)
-> (Ptr VkPipelineCoverageModulationStateCreateFlagsNV
    -> VkPipelineCoverageModulationStateCreateFlagsNV -> IO ())
-> Storable VkPipelineCoverageModulationStateCreateFlagsNV
forall b.
Ptr b -> Int -> IO VkPipelineCoverageModulationStateCreateFlagsNV
forall b.
Ptr b
-> Int -> VkPipelineCoverageModulationStateCreateFlagsNV -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr VkPipelineCoverageModulationStateCreateFlagsNV
-> VkPipelineCoverageModulationStateCreateFlagsNV -> IO ()
$cpoke :: Ptr VkPipelineCoverageModulationStateCreateFlagsNV
-> VkPipelineCoverageModulationStateCreateFlagsNV -> IO ()
peek :: Ptr VkPipelineCoverageModulationStateCreateFlagsNV
-> IO VkPipelineCoverageModulationStateCreateFlagsNV
$cpeek :: Ptr VkPipelineCoverageModulationStateCreateFlagsNV
-> IO VkPipelineCoverageModulationStateCreateFlagsNV
pokeByteOff :: forall b.
Ptr b
-> Int -> VkPipelineCoverageModulationStateCreateFlagsNV -> IO ()
$cpokeByteOff :: forall b.
Ptr b
-> Int -> VkPipelineCoverageModulationStateCreateFlagsNV -> IO ()
peekByteOff :: forall b.
Ptr b -> Int -> IO VkPipelineCoverageModulationStateCreateFlagsNV
$cpeekByteOff :: forall b.
Ptr b -> Int -> IO VkPipelineCoverageModulationStateCreateFlagsNV
pokeElemOff :: Ptr VkPipelineCoverageModulationStateCreateFlagsNV
-> Int -> VkPipelineCoverageModulationStateCreateFlagsNV -> IO ()
$cpokeElemOff :: Ptr VkPipelineCoverageModulationStateCreateFlagsNV
-> Int -> VkPipelineCoverageModulationStateCreateFlagsNV -> IO ()
peekElemOff :: Ptr VkPipelineCoverageModulationStateCreateFlagsNV
-> Int -> IO VkPipelineCoverageModulationStateCreateFlagsNV
$cpeekElemOff :: Ptr VkPipelineCoverageModulationStateCreateFlagsNV
-> Int -> IO VkPipelineCoverageModulationStateCreateFlagsNV
alignment :: VkPipelineCoverageModulationStateCreateFlagsNV -> Int
$calignment :: VkPipelineCoverageModulationStateCreateFlagsNV -> Int
sizeOf :: VkPipelineCoverageModulationStateCreateFlagsNV -> Int
$csizeOf :: VkPipelineCoverageModulationStateCreateFlagsNV -> Int
Storable)

instance Show VkPipelineCoverageModulationStateCreateFlagsNV where
    {-# INLINE showsPrec #-}
    showsPrec :: Int -> VkPipelineCoverageModulationStateCreateFlagsNV -> ShowS
showsPrec = (Int -> VkFlags -> ShowS)
-> Int -> VkPipelineCoverageModulationStateCreateFlagsNV -> ShowS
coerce (Int -> VkFlags -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec :: Int -> VkFlags -> ShowS)

instance Read VkPipelineCoverageModulationStateCreateFlagsNV where
    {-# INLINE readsPrec #-}
    readsPrec :: Int -> ReadS VkPipelineCoverageModulationStateCreateFlagsNV
readsPrec = (Int -> ReadS VkFlags)
-> Int -> ReadS VkPipelineCoverageModulationStateCreateFlagsNV
coerce (Int -> ReadS VkFlags
forall a. Read a => Int -> ReadS a
readsPrec :: Int -> ReadS VkFlags)

newtype VkPipelineCoverageReductionStateCreateFlagsNV = VkPipelineCoverageReductionStateCreateFlagsNV VkFlags
                                                        deriving (VkPipelineCoverageReductionStateCreateFlagsNV
-> VkPipelineCoverageReductionStateCreateFlagsNV -> Bool
(VkPipelineCoverageReductionStateCreateFlagsNV
 -> VkPipelineCoverageReductionStateCreateFlagsNV -> Bool)
-> (VkPipelineCoverageReductionStateCreateFlagsNV
    -> VkPipelineCoverageReductionStateCreateFlagsNV -> Bool)
-> Eq VkPipelineCoverageReductionStateCreateFlagsNV
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VkPipelineCoverageReductionStateCreateFlagsNV
-> VkPipelineCoverageReductionStateCreateFlagsNV -> Bool
$c/= :: VkPipelineCoverageReductionStateCreateFlagsNV
-> VkPipelineCoverageReductionStateCreateFlagsNV -> Bool
== :: VkPipelineCoverageReductionStateCreateFlagsNV
-> VkPipelineCoverageReductionStateCreateFlagsNV -> Bool
$c== :: VkPipelineCoverageReductionStateCreateFlagsNV
-> VkPipelineCoverageReductionStateCreateFlagsNV -> Bool
Eq, Eq VkPipelineCoverageReductionStateCreateFlagsNV
Eq VkPipelineCoverageReductionStateCreateFlagsNV
-> (VkPipelineCoverageReductionStateCreateFlagsNV
    -> VkPipelineCoverageReductionStateCreateFlagsNV -> Ordering)
-> (VkPipelineCoverageReductionStateCreateFlagsNV
    -> VkPipelineCoverageReductionStateCreateFlagsNV -> Bool)
-> (VkPipelineCoverageReductionStateCreateFlagsNV
    -> VkPipelineCoverageReductionStateCreateFlagsNV -> Bool)
-> (VkPipelineCoverageReductionStateCreateFlagsNV
    -> VkPipelineCoverageReductionStateCreateFlagsNV -> Bool)
-> (VkPipelineCoverageReductionStateCreateFlagsNV
    -> VkPipelineCoverageReductionStateCreateFlagsNV -> Bool)
-> (VkPipelineCoverageReductionStateCreateFlagsNV
    -> VkPipelineCoverageReductionStateCreateFlagsNV
    -> VkPipelineCoverageReductionStateCreateFlagsNV)
-> (VkPipelineCoverageReductionStateCreateFlagsNV
    -> VkPipelineCoverageReductionStateCreateFlagsNV
    -> VkPipelineCoverageReductionStateCreateFlagsNV)
-> Ord VkPipelineCoverageReductionStateCreateFlagsNV
VkPipelineCoverageReductionStateCreateFlagsNV
-> VkPipelineCoverageReductionStateCreateFlagsNV -> Bool
VkPipelineCoverageReductionStateCreateFlagsNV
-> VkPipelineCoverageReductionStateCreateFlagsNV -> Ordering
VkPipelineCoverageReductionStateCreateFlagsNV
-> VkPipelineCoverageReductionStateCreateFlagsNV
-> VkPipelineCoverageReductionStateCreateFlagsNV
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: VkPipelineCoverageReductionStateCreateFlagsNV
-> VkPipelineCoverageReductionStateCreateFlagsNV
-> VkPipelineCoverageReductionStateCreateFlagsNV
$cmin :: VkPipelineCoverageReductionStateCreateFlagsNV
-> VkPipelineCoverageReductionStateCreateFlagsNV
-> VkPipelineCoverageReductionStateCreateFlagsNV
max :: VkPipelineCoverageReductionStateCreateFlagsNV
-> VkPipelineCoverageReductionStateCreateFlagsNV
-> VkPipelineCoverageReductionStateCreateFlagsNV
$cmax :: VkPipelineCoverageReductionStateCreateFlagsNV
-> VkPipelineCoverageReductionStateCreateFlagsNV
-> VkPipelineCoverageReductionStateCreateFlagsNV
>= :: VkPipelineCoverageReductionStateCreateFlagsNV
-> VkPipelineCoverageReductionStateCreateFlagsNV -> Bool
$c>= :: VkPipelineCoverageReductionStateCreateFlagsNV
-> VkPipelineCoverageReductionStateCreateFlagsNV -> Bool
> :: VkPipelineCoverageReductionStateCreateFlagsNV
-> VkPipelineCoverageReductionStateCreateFlagsNV -> Bool
$c> :: VkPipelineCoverageReductionStateCreateFlagsNV
-> VkPipelineCoverageReductionStateCreateFlagsNV -> Bool
<= :: VkPipelineCoverageReductionStateCreateFlagsNV
-> VkPipelineCoverageReductionStateCreateFlagsNV -> Bool
$c<= :: VkPipelineCoverageReductionStateCreateFlagsNV
-> VkPipelineCoverageReductionStateCreateFlagsNV -> Bool
< :: VkPipelineCoverageReductionStateCreateFlagsNV
-> VkPipelineCoverageReductionStateCreateFlagsNV -> Bool
$c< :: VkPipelineCoverageReductionStateCreateFlagsNV
-> VkPipelineCoverageReductionStateCreateFlagsNV -> Bool
compare :: VkPipelineCoverageReductionStateCreateFlagsNV
-> VkPipelineCoverageReductionStateCreateFlagsNV -> Ordering
$ccompare :: VkPipelineCoverageReductionStateCreateFlagsNV
-> VkPipelineCoverageReductionStateCreateFlagsNV -> Ordering
Ord, Int -> VkPipelineCoverageReductionStateCreateFlagsNV
VkPipelineCoverageReductionStateCreateFlagsNV -> Int
VkPipelineCoverageReductionStateCreateFlagsNV
-> [VkPipelineCoverageReductionStateCreateFlagsNV]
VkPipelineCoverageReductionStateCreateFlagsNV
-> VkPipelineCoverageReductionStateCreateFlagsNV
VkPipelineCoverageReductionStateCreateFlagsNV
-> VkPipelineCoverageReductionStateCreateFlagsNV
-> [VkPipelineCoverageReductionStateCreateFlagsNV]
VkPipelineCoverageReductionStateCreateFlagsNV
-> VkPipelineCoverageReductionStateCreateFlagsNV
-> VkPipelineCoverageReductionStateCreateFlagsNV
-> [VkPipelineCoverageReductionStateCreateFlagsNV]
(VkPipelineCoverageReductionStateCreateFlagsNV
 -> VkPipelineCoverageReductionStateCreateFlagsNV)
-> (VkPipelineCoverageReductionStateCreateFlagsNV
    -> VkPipelineCoverageReductionStateCreateFlagsNV)
-> (Int -> VkPipelineCoverageReductionStateCreateFlagsNV)
-> (VkPipelineCoverageReductionStateCreateFlagsNV -> Int)
-> (VkPipelineCoverageReductionStateCreateFlagsNV
    -> [VkPipelineCoverageReductionStateCreateFlagsNV])
-> (VkPipelineCoverageReductionStateCreateFlagsNV
    -> VkPipelineCoverageReductionStateCreateFlagsNV
    -> [VkPipelineCoverageReductionStateCreateFlagsNV])
-> (VkPipelineCoverageReductionStateCreateFlagsNV
    -> VkPipelineCoverageReductionStateCreateFlagsNV
    -> [VkPipelineCoverageReductionStateCreateFlagsNV])
-> (VkPipelineCoverageReductionStateCreateFlagsNV
    -> VkPipelineCoverageReductionStateCreateFlagsNV
    -> VkPipelineCoverageReductionStateCreateFlagsNV
    -> [VkPipelineCoverageReductionStateCreateFlagsNV])
-> Enum VkPipelineCoverageReductionStateCreateFlagsNV
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: VkPipelineCoverageReductionStateCreateFlagsNV
-> VkPipelineCoverageReductionStateCreateFlagsNV
-> VkPipelineCoverageReductionStateCreateFlagsNV
-> [VkPipelineCoverageReductionStateCreateFlagsNV]
$cenumFromThenTo :: VkPipelineCoverageReductionStateCreateFlagsNV
-> VkPipelineCoverageReductionStateCreateFlagsNV
-> VkPipelineCoverageReductionStateCreateFlagsNV
-> [VkPipelineCoverageReductionStateCreateFlagsNV]
enumFromTo :: VkPipelineCoverageReductionStateCreateFlagsNV
-> VkPipelineCoverageReductionStateCreateFlagsNV
-> [VkPipelineCoverageReductionStateCreateFlagsNV]
$cenumFromTo :: VkPipelineCoverageReductionStateCreateFlagsNV
-> VkPipelineCoverageReductionStateCreateFlagsNV
-> [VkPipelineCoverageReductionStateCreateFlagsNV]
enumFromThen :: VkPipelineCoverageReductionStateCreateFlagsNV
-> VkPipelineCoverageReductionStateCreateFlagsNV
-> [VkPipelineCoverageReductionStateCreateFlagsNV]
$cenumFromThen :: VkPipelineCoverageReductionStateCreateFlagsNV
-> VkPipelineCoverageReductionStateCreateFlagsNV
-> [VkPipelineCoverageReductionStateCreateFlagsNV]
enumFrom :: VkPipelineCoverageReductionStateCreateFlagsNV
-> [VkPipelineCoverageReductionStateCreateFlagsNV]
$cenumFrom :: VkPipelineCoverageReductionStateCreateFlagsNV
-> [VkPipelineCoverageReductionStateCreateFlagsNV]
fromEnum :: VkPipelineCoverageReductionStateCreateFlagsNV -> Int
$cfromEnum :: VkPipelineCoverageReductionStateCreateFlagsNV -> Int
toEnum :: Int -> VkPipelineCoverageReductionStateCreateFlagsNV
$ctoEnum :: Int -> VkPipelineCoverageReductionStateCreateFlagsNV
pred :: VkPipelineCoverageReductionStateCreateFlagsNV
-> VkPipelineCoverageReductionStateCreateFlagsNV
$cpred :: VkPipelineCoverageReductionStateCreateFlagsNV
-> VkPipelineCoverageReductionStateCreateFlagsNV
succ :: VkPipelineCoverageReductionStateCreateFlagsNV
-> VkPipelineCoverageReductionStateCreateFlagsNV
$csucc :: VkPipelineCoverageReductionStateCreateFlagsNV
-> VkPipelineCoverageReductionStateCreateFlagsNV
Enum, Eq VkPipelineCoverageReductionStateCreateFlagsNV
VkPipelineCoverageReductionStateCreateFlagsNV
Eq VkPipelineCoverageReductionStateCreateFlagsNV
-> (VkPipelineCoverageReductionStateCreateFlagsNV
    -> VkPipelineCoverageReductionStateCreateFlagsNV
    -> VkPipelineCoverageReductionStateCreateFlagsNV)
-> (VkPipelineCoverageReductionStateCreateFlagsNV
    -> VkPipelineCoverageReductionStateCreateFlagsNV
    -> VkPipelineCoverageReductionStateCreateFlagsNV)
-> (VkPipelineCoverageReductionStateCreateFlagsNV
    -> VkPipelineCoverageReductionStateCreateFlagsNV
    -> VkPipelineCoverageReductionStateCreateFlagsNV)
-> (VkPipelineCoverageReductionStateCreateFlagsNV
    -> VkPipelineCoverageReductionStateCreateFlagsNV)
-> (VkPipelineCoverageReductionStateCreateFlagsNV
    -> Int -> VkPipelineCoverageReductionStateCreateFlagsNV)
-> (VkPipelineCoverageReductionStateCreateFlagsNV
    -> Int -> VkPipelineCoverageReductionStateCreateFlagsNV)
-> VkPipelineCoverageReductionStateCreateFlagsNV
-> (Int -> VkPipelineCoverageReductionStateCreateFlagsNV)
-> (VkPipelineCoverageReductionStateCreateFlagsNV
    -> Int -> VkPipelineCoverageReductionStateCreateFlagsNV)
-> (VkPipelineCoverageReductionStateCreateFlagsNV
    -> Int -> VkPipelineCoverageReductionStateCreateFlagsNV)
-> (VkPipelineCoverageReductionStateCreateFlagsNV
    -> Int -> VkPipelineCoverageReductionStateCreateFlagsNV)
-> (VkPipelineCoverageReductionStateCreateFlagsNV -> Int -> Bool)
-> (VkPipelineCoverageReductionStateCreateFlagsNV -> Maybe Int)
-> (VkPipelineCoverageReductionStateCreateFlagsNV -> Int)
-> (VkPipelineCoverageReductionStateCreateFlagsNV -> Bool)
-> (VkPipelineCoverageReductionStateCreateFlagsNV
    -> Int -> VkPipelineCoverageReductionStateCreateFlagsNV)
-> (VkPipelineCoverageReductionStateCreateFlagsNV
    -> Int -> VkPipelineCoverageReductionStateCreateFlagsNV)
-> (VkPipelineCoverageReductionStateCreateFlagsNV
    -> Int -> VkPipelineCoverageReductionStateCreateFlagsNV)
-> (VkPipelineCoverageReductionStateCreateFlagsNV
    -> Int -> VkPipelineCoverageReductionStateCreateFlagsNV)
-> (VkPipelineCoverageReductionStateCreateFlagsNV
    -> Int -> VkPipelineCoverageReductionStateCreateFlagsNV)
-> (VkPipelineCoverageReductionStateCreateFlagsNV
    -> Int -> VkPipelineCoverageReductionStateCreateFlagsNV)
-> (VkPipelineCoverageReductionStateCreateFlagsNV -> Int)
-> Bits VkPipelineCoverageReductionStateCreateFlagsNV
Int -> VkPipelineCoverageReductionStateCreateFlagsNV
VkPipelineCoverageReductionStateCreateFlagsNV -> Bool
VkPipelineCoverageReductionStateCreateFlagsNV -> Int
VkPipelineCoverageReductionStateCreateFlagsNV -> Maybe Int
VkPipelineCoverageReductionStateCreateFlagsNV
-> VkPipelineCoverageReductionStateCreateFlagsNV
VkPipelineCoverageReductionStateCreateFlagsNV -> Int -> Bool
VkPipelineCoverageReductionStateCreateFlagsNV
-> Int -> VkPipelineCoverageReductionStateCreateFlagsNV
VkPipelineCoverageReductionStateCreateFlagsNV
-> VkPipelineCoverageReductionStateCreateFlagsNV
-> VkPipelineCoverageReductionStateCreateFlagsNV
forall a.
Eq a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
popCount :: VkPipelineCoverageReductionStateCreateFlagsNV -> Int
$cpopCount :: VkPipelineCoverageReductionStateCreateFlagsNV -> Int
rotateR :: VkPipelineCoverageReductionStateCreateFlagsNV
-> Int -> VkPipelineCoverageReductionStateCreateFlagsNV
$crotateR :: VkPipelineCoverageReductionStateCreateFlagsNV
-> Int -> VkPipelineCoverageReductionStateCreateFlagsNV
rotateL :: VkPipelineCoverageReductionStateCreateFlagsNV
-> Int -> VkPipelineCoverageReductionStateCreateFlagsNV
$crotateL :: VkPipelineCoverageReductionStateCreateFlagsNV
-> Int -> VkPipelineCoverageReductionStateCreateFlagsNV
unsafeShiftR :: VkPipelineCoverageReductionStateCreateFlagsNV
-> Int -> VkPipelineCoverageReductionStateCreateFlagsNV
$cunsafeShiftR :: VkPipelineCoverageReductionStateCreateFlagsNV
-> Int -> VkPipelineCoverageReductionStateCreateFlagsNV
shiftR :: VkPipelineCoverageReductionStateCreateFlagsNV
-> Int -> VkPipelineCoverageReductionStateCreateFlagsNV
$cshiftR :: VkPipelineCoverageReductionStateCreateFlagsNV
-> Int -> VkPipelineCoverageReductionStateCreateFlagsNV
unsafeShiftL :: VkPipelineCoverageReductionStateCreateFlagsNV
-> Int -> VkPipelineCoverageReductionStateCreateFlagsNV
$cunsafeShiftL :: VkPipelineCoverageReductionStateCreateFlagsNV
-> Int -> VkPipelineCoverageReductionStateCreateFlagsNV
shiftL :: VkPipelineCoverageReductionStateCreateFlagsNV
-> Int -> VkPipelineCoverageReductionStateCreateFlagsNV
$cshiftL :: VkPipelineCoverageReductionStateCreateFlagsNV
-> Int -> VkPipelineCoverageReductionStateCreateFlagsNV
isSigned :: VkPipelineCoverageReductionStateCreateFlagsNV -> Bool
$cisSigned :: VkPipelineCoverageReductionStateCreateFlagsNV -> Bool
bitSize :: VkPipelineCoverageReductionStateCreateFlagsNV -> Int
$cbitSize :: VkPipelineCoverageReductionStateCreateFlagsNV -> Int
bitSizeMaybe :: VkPipelineCoverageReductionStateCreateFlagsNV -> Maybe Int
$cbitSizeMaybe :: VkPipelineCoverageReductionStateCreateFlagsNV -> Maybe Int
testBit :: VkPipelineCoverageReductionStateCreateFlagsNV -> Int -> Bool
$ctestBit :: VkPipelineCoverageReductionStateCreateFlagsNV -> Int -> Bool
complementBit :: VkPipelineCoverageReductionStateCreateFlagsNV
-> Int -> VkPipelineCoverageReductionStateCreateFlagsNV
$ccomplementBit :: VkPipelineCoverageReductionStateCreateFlagsNV
-> Int -> VkPipelineCoverageReductionStateCreateFlagsNV
clearBit :: VkPipelineCoverageReductionStateCreateFlagsNV
-> Int -> VkPipelineCoverageReductionStateCreateFlagsNV
$cclearBit :: VkPipelineCoverageReductionStateCreateFlagsNV
-> Int -> VkPipelineCoverageReductionStateCreateFlagsNV
setBit :: VkPipelineCoverageReductionStateCreateFlagsNV
-> Int -> VkPipelineCoverageReductionStateCreateFlagsNV
$csetBit :: VkPipelineCoverageReductionStateCreateFlagsNV
-> Int -> VkPipelineCoverageReductionStateCreateFlagsNV
bit :: Int -> VkPipelineCoverageReductionStateCreateFlagsNV
$cbit :: Int -> VkPipelineCoverageReductionStateCreateFlagsNV
zeroBits :: VkPipelineCoverageReductionStateCreateFlagsNV
$czeroBits :: VkPipelineCoverageReductionStateCreateFlagsNV
rotate :: VkPipelineCoverageReductionStateCreateFlagsNV
-> Int -> VkPipelineCoverageReductionStateCreateFlagsNV
$crotate :: VkPipelineCoverageReductionStateCreateFlagsNV
-> Int -> VkPipelineCoverageReductionStateCreateFlagsNV
shift :: VkPipelineCoverageReductionStateCreateFlagsNV
-> Int -> VkPipelineCoverageReductionStateCreateFlagsNV
$cshift :: VkPipelineCoverageReductionStateCreateFlagsNV
-> Int -> VkPipelineCoverageReductionStateCreateFlagsNV
complement :: VkPipelineCoverageReductionStateCreateFlagsNV
-> VkPipelineCoverageReductionStateCreateFlagsNV
$ccomplement :: VkPipelineCoverageReductionStateCreateFlagsNV
-> VkPipelineCoverageReductionStateCreateFlagsNV
xor :: VkPipelineCoverageReductionStateCreateFlagsNV
-> VkPipelineCoverageReductionStateCreateFlagsNV
-> VkPipelineCoverageReductionStateCreateFlagsNV
$cxor :: VkPipelineCoverageReductionStateCreateFlagsNV
-> VkPipelineCoverageReductionStateCreateFlagsNV
-> VkPipelineCoverageReductionStateCreateFlagsNV
.|. :: VkPipelineCoverageReductionStateCreateFlagsNV
-> VkPipelineCoverageReductionStateCreateFlagsNV
-> VkPipelineCoverageReductionStateCreateFlagsNV
$c.|. :: VkPipelineCoverageReductionStateCreateFlagsNV
-> VkPipelineCoverageReductionStateCreateFlagsNV
-> VkPipelineCoverageReductionStateCreateFlagsNV
.&. :: VkPipelineCoverageReductionStateCreateFlagsNV
-> VkPipelineCoverageReductionStateCreateFlagsNV
-> VkPipelineCoverageReductionStateCreateFlagsNV
$c.&. :: VkPipelineCoverageReductionStateCreateFlagsNV
-> VkPipelineCoverageReductionStateCreateFlagsNV
-> VkPipelineCoverageReductionStateCreateFlagsNV
Bits, Bits VkPipelineCoverageReductionStateCreateFlagsNV
Bits VkPipelineCoverageReductionStateCreateFlagsNV
-> (VkPipelineCoverageReductionStateCreateFlagsNV -> Int)
-> (VkPipelineCoverageReductionStateCreateFlagsNV -> Int)
-> (VkPipelineCoverageReductionStateCreateFlagsNV -> Int)
-> FiniteBits VkPipelineCoverageReductionStateCreateFlagsNV
VkPipelineCoverageReductionStateCreateFlagsNV -> Int
forall b.
Bits b -> (b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
countTrailingZeros :: VkPipelineCoverageReductionStateCreateFlagsNV -> Int
$ccountTrailingZeros :: VkPipelineCoverageReductionStateCreateFlagsNV -> Int
countLeadingZeros :: VkPipelineCoverageReductionStateCreateFlagsNV -> Int
$ccountLeadingZeros :: VkPipelineCoverageReductionStateCreateFlagsNV -> Int
finiteBitSize :: VkPipelineCoverageReductionStateCreateFlagsNV -> Int
$cfiniteBitSize :: VkPipelineCoverageReductionStateCreateFlagsNV -> Int
FiniteBits,
                                                                  Ptr VkPipelineCoverageReductionStateCreateFlagsNV
-> IO VkPipelineCoverageReductionStateCreateFlagsNV
Ptr VkPipelineCoverageReductionStateCreateFlagsNV
-> Int -> IO VkPipelineCoverageReductionStateCreateFlagsNV
Ptr VkPipelineCoverageReductionStateCreateFlagsNV
-> Int -> VkPipelineCoverageReductionStateCreateFlagsNV -> IO ()
Ptr VkPipelineCoverageReductionStateCreateFlagsNV
-> VkPipelineCoverageReductionStateCreateFlagsNV -> IO ()
VkPipelineCoverageReductionStateCreateFlagsNV -> Int
(VkPipelineCoverageReductionStateCreateFlagsNV -> Int)
-> (VkPipelineCoverageReductionStateCreateFlagsNV -> Int)
-> (Ptr VkPipelineCoverageReductionStateCreateFlagsNV
    -> Int -> IO VkPipelineCoverageReductionStateCreateFlagsNV)
-> (Ptr VkPipelineCoverageReductionStateCreateFlagsNV
    -> Int -> VkPipelineCoverageReductionStateCreateFlagsNV -> IO ())
-> (forall b.
    Ptr b -> Int -> IO VkPipelineCoverageReductionStateCreateFlagsNV)
-> (forall b.
    Ptr b
    -> Int -> VkPipelineCoverageReductionStateCreateFlagsNV -> IO ())
-> (Ptr VkPipelineCoverageReductionStateCreateFlagsNV
    -> IO VkPipelineCoverageReductionStateCreateFlagsNV)
-> (Ptr VkPipelineCoverageReductionStateCreateFlagsNV
    -> VkPipelineCoverageReductionStateCreateFlagsNV -> IO ())
-> Storable VkPipelineCoverageReductionStateCreateFlagsNV
forall b.
Ptr b -> Int -> IO VkPipelineCoverageReductionStateCreateFlagsNV
forall b.
Ptr b
-> Int -> VkPipelineCoverageReductionStateCreateFlagsNV -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr VkPipelineCoverageReductionStateCreateFlagsNV
-> VkPipelineCoverageReductionStateCreateFlagsNV -> IO ()
$cpoke :: Ptr VkPipelineCoverageReductionStateCreateFlagsNV
-> VkPipelineCoverageReductionStateCreateFlagsNV -> IO ()
peek :: Ptr VkPipelineCoverageReductionStateCreateFlagsNV
-> IO VkPipelineCoverageReductionStateCreateFlagsNV
$cpeek :: Ptr VkPipelineCoverageReductionStateCreateFlagsNV
-> IO VkPipelineCoverageReductionStateCreateFlagsNV
pokeByteOff :: forall b.
Ptr b
-> Int -> VkPipelineCoverageReductionStateCreateFlagsNV -> IO ()
$cpokeByteOff :: forall b.
Ptr b
-> Int -> VkPipelineCoverageReductionStateCreateFlagsNV -> IO ()
peekByteOff :: forall b.
Ptr b -> Int -> IO VkPipelineCoverageReductionStateCreateFlagsNV
$cpeekByteOff :: forall b.
Ptr b -> Int -> IO VkPipelineCoverageReductionStateCreateFlagsNV
pokeElemOff :: Ptr VkPipelineCoverageReductionStateCreateFlagsNV
-> Int -> VkPipelineCoverageReductionStateCreateFlagsNV -> IO ()
$cpokeElemOff :: Ptr VkPipelineCoverageReductionStateCreateFlagsNV
-> Int -> VkPipelineCoverageReductionStateCreateFlagsNV -> IO ()
peekElemOff :: Ptr VkPipelineCoverageReductionStateCreateFlagsNV
-> Int -> IO VkPipelineCoverageReductionStateCreateFlagsNV
$cpeekElemOff :: Ptr VkPipelineCoverageReductionStateCreateFlagsNV
-> Int -> IO VkPipelineCoverageReductionStateCreateFlagsNV
alignment :: VkPipelineCoverageReductionStateCreateFlagsNV -> Int
$calignment :: VkPipelineCoverageReductionStateCreateFlagsNV -> Int
sizeOf :: VkPipelineCoverageReductionStateCreateFlagsNV -> Int
$csizeOf :: VkPipelineCoverageReductionStateCreateFlagsNV -> Int
Storable)

instance Show VkPipelineCoverageReductionStateCreateFlagsNV where
    {-# INLINE showsPrec #-}
    showsPrec :: Int -> VkPipelineCoverageReductionStateCreateFlagsNV -> ShowS
showsPrec = (Int -> VkFlags -> ShowS)
-> Int -> VkPipelineCoverageReductionStateCreateFlagsNV -> ShowS
coerce (Int -> VkFlags -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec :: Int -> VkFlags -> ShowS)

instance Read VkPipelineCoverageReductionStateCreateFlagsNV where
    {-# INLINE readsPrec #-}
    readsPrec :: Int -> ReadS VkPipelineCoverageReductionStateCreateFlagsNV
readsPrec = (Int -> ReadS VkFlags)
-> Int -> ReadS VkPipelineCoverageReductionStateCreateFlagsNV
coerce (Int -> ReadS VkFlags
forall a. Read a => Int -> ReadS a
readsPrec :: Int -> ReadS VkFlags)

newtype VkPipelineCoverageToColorStateCreateFlagsNV = VkPipelineCoverageToColorStateCreateFlagsNV VkFlags
                                                      deriving (VkPipelineCoverageToColorStateCreateFlagsNV
-> VkPipelineCoverageToColorStateCreateFlagsNV -> Bool
(VkPipelineCoverageToColorStateCreateFlagsNV
 -> VkPipelineCoverageToColorStateCreateFlagsNV -> Bool)
-> (VkPipelineCoverageToColorStateCreateFlagsNV
    -> VkPipelineCoverageToColorStateCreateFlagsNV -> Bool)
-> Eq VkPipelineCoverageToColorStateCreateFlagsNV
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VkPipelineCoverageToColorStateCreateFlagsNV
-> VkPipelineCoverageToColorStateCreateFlagsNV -> Bool
$c/= :: VkPipelineCoverageToColorStateCreateFlagsNV
-> VkPipelineCoverageToColorStateCreateFlagsNV -> Bool
== :: VkPipelineCoverageToColorStateCreateFlagsNV
-> VkPipelineCoverageToColorStateCreateFlagsNV -> Bool
$c== :: VkPipelineCoverageToColorStateCreateFlagsNV
-> VkPipelineCoverageToColorStateCreateFlagsNV -> Bool
Eq, Eq VkPipelineCoverageToColorStateCreateFlagsNV
Eq VkPipelineCoverageToColorStateCreateFlagsNV
-> (VkPipelineCoverageToColorStateCreateFlagsNV
    -> VkPipelineCoverageToColorStateCreateFlagsNV -> Ordering)
-> (VkPipelineCoverageToColorStateCreateFlagsNV
    -> VkPipelineCoverageToColorStateCreateFlagsNV -> Bool)
-> (VkPipelineCoverageToColorStateCreateFlagsNV
    -> VkPipelineCoverageToColorStateCreateFlagsNV -> Bool)
-> (VkPipelineCoverageToColorStateCreateFlagsNV
    -> VkPipelineCoverageToColorStateCreateFlagsNV -> Bool)
-> (VkPipelineCoverageToColorStateCreateFlagsNV
    -> VkPipelineCoverageToColorStateCreateFlagsNV -> Bool)
-> (VkPipelineCoverageToColorStateCreateFlagsNV
    -> VkPipelineCoverageToColorStateCreateFlagsNV
    -> VkPipelineCoverageToColorStateCreateFlagsNV)
-> (VkPipelineCoverageToColorStateCreateFlagsNV
    -> VkPipelineCoverageToColorStateCreateFlagsNV
    -> VkPipelineCoverageToColorStateCreateFlagsNV)
-> Ord VkPipelineCoverageToColorStateCreateFlagsNV
VkPipelineCoverageToColorStateCreateFlagsNV
-> VkPipelineCoverageToColorStateCreateFlagsNV -> Bool
VkPipelineCoverageToColorStateCreateFlagsNV
-> VkPipelineCoverageToColorStateCreateFlagsNV -> Ordering
VkPipelineCoverageToColorStateCreateFlagsNV
-> VkPipelineCoverageToColorStateCreateFlagsNV
-> VkPipelineCoverageToColorStateCreateFlagsNV
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: VkPipelineCoverageToColorStateCreateFlagsNV
-> VkPipelineCoverageToColorStateCreateFlagsNV
-> VkPipelineCoverageToColorStateCreateFlagsNV
$cmin :: VkPipelineCoverageToColorStateCreateFlagsNV
-> VkPipelineCoverageToColorStateCreateFlagsNV
-> VkPipelineCoverageToColorStateCreateFlagsNV
max :: VkPipelineCoverageToColorStateCreateFlagsNV
-> VkPipelineCoverageToColorStateCreateFlagsNV
-> VkPipelineCoverageToColorStateCreateFlagsNV
$cmax :: VkPipelineCoverageToColorStateCreateFlagsNV
-> VkPipelineCoverageToColorStateCreateFlagsNV
-> VkPipelineCoverageToColorStateCreateFlagsNV
>= :: VkPipelineCoverageToColorStateCreateFlagsNV
-> VkPipelineCoverageToColorStateCreateFlagsNV -> Bool
$c>= :: VkPipelineCoverageToColorStateCreateFlagsNV
-> VkPipelineCoverageToColorStateCreateFlagsNV -> Bool
> :: VkPipelineCoverageToColorStateCreateFlagsNV
-> VkPipelineCoverageToColorStateCreateFlagsNV -> Bool
$c> :: VkPipelineCoverageToColorStateCreateFlagsNV
-> VkPipelineCoverageToColorStateCreateFlagsNV -> Bool
<= :: VkPipelineCoverageToColorStateCreateFlagsNV
-> VkPipelineCoverageToColorStateCreateFlagsNV -> Bool
$c<= :: VkPipelineCoverageToColorStateCreateFlagsNV
-> VkPipelineCoverageToColorStateCreateFlagsNV -> Bool
< :: VkPipelineCoverageToColorStateCreateFlagsNV
-> VkPipelineCoverageToColorStateCreateFlagsNV -> Bool
$c< :: VkPipelineCoverageToColorStateCreateFlagsNV
-> VkPipelineCoverageToColorStateCreateFlagsNV -> Bool
compare :: VkPipelineCoverageToColorStateCreateFlagsNV
-> VkPipelineCoverageToColorStateCreateFlagsNV -> Ordering
$ccompare :: VkPipelineCoverageToColorStateCreateFlagsNV
-> VkPipelineCoverageToColorStateCreateFlagsNV -> Ordering
Ord, Int -> VkPipelineCoverageToColorStateCreateFlagsNV
VkPipelineCoverageToColorStateCreateFlagsNV -> Int
VkPipelineCoverageToColorStateCreateFlagsNV
-> [VkPipelineCoverageToColorStateCreateFlagsNV]
VkPipelineCoverageToColorStateCreateFlagsNV
-> VkPipelineCoverageToColorStateCreateFlagsNV
VkPipelineCoverageToColorStateCreateFlagsNV
-> VkPipelineCoverageToColorStateCreateFlagsNV
-> [VkPipelineCoverageToColorStateCreateFlagsNV]
VkPipelineCoverageToColorStateCreateFlagsNV
-> VkPipelineCoverageToColorStateCreateFlagsNV
-> VkPipelineCoverageToColorStateCreateFlagsNV
-> [VkPipelineCoverageToColorStateCreateFlagsNV]
(VkPipelineCoverageToColorStateCreateFlagsNV
 -> VkPipelineCoverageToColorStateCreateFlagsNV)
-> (VkPipelineCoverageToColorStateCreateFlagsNV
    -> VkPipelineCoverageToColorStateCreateFlagsNV)
-> (Int -> VkPipelineCoverageToColorStateCreateFlagsNV)
-> (VkPipelineCoverageToColorStateCreateFlagsNV -> Int)
-> (VkPipelineCoverageToColorStateCreateFlagsNV
    -> [VkPipelineCoverageToColorStateCreateFlagsNV])
-> (VkPipelineCoverageToColorStateCreateFlagsNV
    -> VkPipelineCoverageToColorStateCreateFlagsNV
    -> [VkPipelineCoverageToColorStateCreateFlagsNV])
-> (VkPipelineCoverageToColorStateCreateFlagsNV
    -> VkPipelineCoverageToColorStateCreateFlagsNV
    -> [VkPipelineCoverageToColorStateCreateFlagsNV])
-> (VkPipelineCoverageToColorStateCreateFlagsNV
    -> VkPipelineCoverageToColorStateCreateFlagsNV
    -> VkPipelineCoverageToColorStateCreateFlagsNV
    -> [VkPipelineCoverageToColorStateCreateFlagsNV])
-> Enum VkPipelineCoverageToColorStateCreateFlagsNV
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: VkPipelineCoverageToColorStateCreateFlagsNV
-> VkPipelineCoverageToColorStateCreateFlagsNV
-> VkPipelineCoverageToColorStateCreateFlagsNV
-> [VkPipelineCoverageToColorStateCreateFlagsNV]
$cenumFromThenTo :: VkPipelineCoverageToColorStateCreateFlagsNV
-> VkPipelineCoverageToColorStateCreateFlagsNV
-> VkPipelineCoverageToColorStateCreateFlagsNV
-> [VkPipelineCoverageToColorStateCreateFlagsNV]
enumFromTo :: VkPipelineCoverageToColorStateCreateFlagsNV
-> VkPipelineCoverageToColorStateCreateFlagsNV
-> [VkPipelineCoverageToColorStateCreateFlagsNV]
$cenumFromTo :: VkPipelineCoverageToColorStateCreateFlagsNV
-> VkPipelineCoverageToColorStateCreateFlagsNV
-> [VkPipelineCoverageToColorStateCreateFlagsNV]
enumFromThen :: VkPipelineCoverageToColorStateCreateFlagsNV
-> VkPipelineCoverageToColorStateCreateFlagsNV
-> [VkPipelineCoverageToColorStateCreateFlagsNV]
$cenumFromThen :: VkPipelineCoverageToColorStateCreateFlagsNV
-> VkPipelineCoverageToColorStateCreateFlagsNV
-> [VkPipelineCoverageToColorStateCreateFlagsNV]
enumFrom :: VkPipelineCoverageToColorStateCreateFlagsNV
-> [VkPipelineCoverageToColorStateCreateFlagsNV]
$cenumFrom :: VkPipelineCoverageToColorStateCreateFlagsNV
-> [VkPipelineCoverageToColorStateCreateFlagsNV]
fromEnum :: VkPipelineCoverageToColorStateCreateFlagsNV -> Int
$cfromEnum :: VkPipelineCoverageToColorStateCreateFlagsNV -> Int
toEnum :: Int -> VkPipelineCoverageToColorStateCreateFlagsNV
$ctoEnum :: Int -> VkPipelineCoverageToColorStateCreateFlagsNV
pred :: VkPipelineCoverageToColorStateCreateFlagsNV
-> VkPipelineCoverageToColorStateCreateFlagsNV
$cpred :: VkPipelineCoverageToColorStateCreateFlagsNV
-> VkPipelineCoverageToColorStateCreateFlagsNV
succ :: VkPipelineCoverageToColorStateCreateFlagsNV
-> VkPipelineCoverageToColorStateCreateFlagsNV
$csucc :: VkPipelineCoverageToColorStateCreateFlagsNV
-> VkPipelineCoverageToColorStateCreateFlagsNV
Enum, Eq VkPipelineCoverageToColorStateCreateFlagsNV
VkPipelineCoverageToColorStateCreateFlagsNV
Eq VkPipelineCoverageToColorStateCreateFlagsNV
-> (VkPipelineCoverageToColorStateCreateFlagsNV
    -> VkPipelineCoverageToColorStateCreateFlagsNV
    -> VkPipelineCoverageToColorStateCreateFlagsNV)
-> (VkPipelineCoverageToColorStateCreateFlagsNV
    -> VkPipelineCoverageToColorStateCreateFlagsNV
    -> VkPipelineCoverageToColorStateCreateFlagsNV)
-> (VkPipelineCoverageToColorStateCreateFlagsNV
    -> VkPipelineCoverageToColorStateCreateFlagsNV
    -> VkPipelineCoverageToColorStateCreateFlagsNV)
-> (VkPipelineCoverageToColorStateCreateFlagsNV
    -> VkPipelineCoverageToColorStateCreateFlagsNV)
-> (VkPipelineCoverageToColorStateCreateFlagsNV
    -> Int -> VkPipelineCoverageToColorStateCreateFlagsNV)
-> (VkPipelineCoverageToColorStateCreateFlagsNV
    -> Int -> VkPipelineCoverageToColorStateCreateFlagsNV)
-> VkPipelineCoverageToColorStateCreateFlagsNV
-> (Int -> VkPipelineCoverageToColorStateCreateFlagsNV)
-> (VkPipelineCoverageToColorStateCreateFlagsNV
    -> Int -> VkPipelineCoverageToColorStateCreateFlagsNV)
-> (VkPipelineCoverageToColorStateCreateFlagsNV
    -> Int -> VkPipelineCoverageToColorStateCreateFlagsNV)
-> (VkPipelineCoverageToColorStateCreateFlagsNV
    -> Int -> VkPipelineCoverageToColorStateCreateFlagsNV)
-> (VkPipelineCoverageToColorStateCreateFlagsNV -> Int -> Bool)
-> (VkPipelineCoverageToColorStateCreateFlagsNV -> Maybe Int)
-> (VkPipelineCoverageToColorStateCreateFlagsNV -> Int)
-> (VkPipelineCoverageToColorStateCreateFlagsNV -> Bool)
-> (VkPipelineCoverageToColorStateCreateFlagsNV
    -> Int -> VkPipelineCoverageToColorStateCreateFlagsNV)
-> (VkPipelineCoverageToColorStateCreateFlagsNV
    -> Int -> VkPipelineCoverageToColorStateCreateFlagsNV)
-> (VkPipelineCoverageToColorStateCreateFlagsNV
    -> Int -> VkPipelineCoverageToColorStateCreateFlagsNV)
-> (VkPipelineCoverageToColorStateCreateFlagsNV
    -> Int -> VkPipelineCoverageToColorStateCreateFlagsNV)
-> (VkPipelineCoverageToColorStateCreateFlagsNV
    -> Int -> VkPipelineCoverageToColorStateCreateFlagsNV)
-> (VkPipelineCoverageToColorStateCreateFlagsNV
    -> Int -> VkPipelineCoverageToColorStateCreateFlagsNV)
-> (VkPipelineCoverageToColorStateCreateFlagsNV -> Int)
-> Bits VkPipelineCoverageToColorStateCreateFlagsNV
Int -> VkPipelineCoverageToColorStateCreateFlagsNV
VkPipelineCoverageToColorStateCreateFlagsNV -> Bool
VkPipelineCoverageToColorStateCreateFlagsNV -> Int
VkPipelineCoverageToColorStateCreateFlagsNV -> Maybe Int
VkPipelineCoverageToColorStateCreateFlagsNV
-> VkPipelineCoverageToColorStateCreateFlagsNV
VkPipelineCoverageToColorStateCreateFlagsNV -> Int -> Bool
VkPipelineCoverageToColorStateCreateFlagsNV
-> Int -> VkPipelineCoverageToColorStateCreateFlagsNV
VkPipelineCoverageToColorStateCreateFlagsNV
-> VkPipelineCoverageToColorStateCreateFlagsNV
-> VkPipelineCoverageToColorStateCreateFlagsNV
forall a.
Eq a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
popCount :: VkPipelineCoverageToColorStateCreateFlagsNV -> Int
$cpopCount :: VkPipelineCoverageToColorStateCreateFlagsNV -> Int
rotateR :: VkPipelineCoverageToColorStateCreateFlagsNV
-> Int -> VkPipelineCoverageToColorStateCreateFlagsNV
$crotateR :: VkPipelineCoverageToColorStateCreateFlagsNV
-> Int -> VkPipelineCoverageToColorStateCreateFlagsNV
rotateL :: VkPipelineCoverageToColorStateCreateFlagsNV
-> Int -> VkPipelineCoverageToColorStateCreateFlagsNV
$crotateL :: VkPipelineCoverageToColorStateCreateFlagsNV
-> Int -> VkPipelineCoverageToColorStateCreateFlagsNV
unsafeShiftR :: VkPipelineCoverageToColorStateCreateFlagsNV
-> Int -> VkPipelineCoverageToColorStateCreateFlagsNV
$cunsafeShiftR :: VkPipelineCoverageToColorStateCreateFlagsNV
-> Int -> VkPipelineCoverageToColorStateCreateFlagsNV
shiftR :: VkPipelineCoverageToColorStateCreateFlagsNV
-> Int -> VkPipelineCoverageToColorStateCreateFlagsNV
$cshiftR :: VkPipelineCoverageToColorStateCreateFlagsNV
-> Int -> VkPipelineCoverageToColorStateCreateFlagsNV
unsafeShiftL :: VkPipelineCoverageToColorStateCreateFlagsNV
-> Int -> VkPipelineCoverageToColorStateCreateFlagsNV
$cunsafeShiftL :: VkPipelineCoverageToColorStateCreateFlagsNV
-> Int -> VkPipelineCoverageToColorStateCreateFlagsNV
shiftL :: VkPipelineCoverageToColorStateCreateFlagsNV
-> Int -> VkPipelineCoverageToColorStateCreateFlagsNV
$cshiftL :: VkPipelineCoverageToColorStateCreateFlagsNV
-> Int -> VkPipelineCoverageToColorStateCreateFlagsNV
isSigned :: VkPipelineCoverageToColorStateCreateFlagsNV -> Bool
$cisSigned :: VkPipelineCoverageToColorStateCreateFlagsNV -> Bool
bitSize :: VkPipelineCoverageToColorStateCreateFlagsNV -> Int
$cbitSize :: VkPipelineCoverageToColorStateCreateFlagsNV -> Int
bitSizeMaybe :: VkPipelineCoverageToColorStateCreateFlagsNV -> Maybe Int
$cbitSizeMaybe :: VkPipelineCoverageToColorStateCreateFlagsNV -> Maybe Int
testBit :: VkPipelineCoverageToColorStateCreateFlagsNV -> Int -> Bool
$ctestBit :: VkPipelineCoverageToColorStateCreateFlagsNV -> Int -> Bool
complementBit :: VkPipelineCoverageToColorStateCreateFlagsNV
-> Int -> VkPipelineCoverageToColorStateCreateFlagsNV
$ccomplementBit :: VkPipelineCoverageToColorStateCreateFlagsNV
-> Int -> VkPipelineCoverageToColorStateCreateFlagsNV
clearBit :: VkPipelineCoverageToColorStateCreateFlagsNV
-> Int -> VkPipelineCoverageToColorStateCreateFlagsNV
$cclearBit :: VkPipelineCoverageToColorStateCreateFlagsNV
-> Int -> VkPipelineCoverageToColorStateCreateFlagsNV
setBit :: VkPipelineCoverageToColorStateCreateFlagsNV
-> Int -> VkPipelineCoverageToColorStateCreateFlagsNV
$csetBit :: VkPipelineCoverageToColorStateCreateFlagsNV
-> Int -> VkPipelineCoverageToColorStateCreateFlagsNV
bit :: Int -> VkPipelineCoverageToColorStateCreateFlagsNV
$cbit :: Int -> VkPipelineCoverageToColorStateCreateFlagsNV
zeroBits :: VkPipelineCoverageToColorStateCreateFlagsNV
$czeroBits :: VkPipelineCoverageToColorStateCreateFlagsNV
rotate :: VkPipelineCoverageToColorStateCreateFlagsNV
-> Int -> VkPipelineCoverageToColorStateCreateFlagsNV
$crotate :: VkPipelineCoverageToColorStateCreateFlagsNV
-> Int -> VkPipelineCoverageToColorStateCreateFlagsNV
shift :: VkPipelineCoverageToColorStateCreateFlagsNV
-> Int -> VkPipelineCoverageToColorStateCreateFlagsNV
$cshift :: VkPipelineCoverageToColorStateCreateFlagsNV
-> Int -> VkPipelineCoverageToColorStateCreateFlagsNV
complement :: VkPipelineCoverageToColorStateCreateFlagsNV
-> VkPipelineCoverageToColorStateCreateFlagsNV
$ccomplement :: VkPipelineCoverageToColorStateCreateFlagsNV
-> VkPipelineCoverageToColorStateCreateFlagsNV
xor :: VkPipelineCoverageToColorStateCreateFlagsNV
-> VkPipelineCoverageToColorStateCreateFlagsNV
-> VkPipelineCoverageToColorStateCreateFlagsNV
$cxor :: VkPipelineCoverageToColorStateCreateFlagsNV
-> VkPipelineCoverageToColorStateCreateFlagsNV
-> VkPipelineCoverageToColorStateCreateFlagsNV
.|. :: VkPipelineCoverageToColorStateCreateFlagsNV
-> VkPipelineCoverageToColorStateCreateFlagsNV
-> VkPipelineCoverageToColorStateCreateFlagsNV
$c.|. :: VkPipelineCoverageToColorStateCreateFlagsNV
-> VkPipelineCoverageToColorStateCreateFlagsNV
-> VkPipelineCoverageToColorStateCreateFlagsNV
.&. :: VkPipelineCoverageToColorStateCreateFlagsNV
-> VkPipelineCoverageToColorStateCreateFlagsNV
-> VkPipelineCoverageToColorStateCreateFlagsNV
$c.&. :: VkPipelineCoverageToColorStateCreateFlagsNV
-> VkPipelineCoverageToColorStateCreateFlagsNV
-> VkPipelineCoverageToColorStateCreateFlagsNV
Bits, Bits VkPipelineCoverageToColorStateCreateFlagsNV
Bits VkPipelineCoverageToColorStateCreateFlagsNV
-> (VkPipelineCoverageToColorStateCreateFlagsNV -> Int)
-> (VkPipelineCoverageToColorStateCreateFlagsNV -> Int)
-> (VkPipelineCoverageToColorStateCreateFlagsNV -> Int)
-> FiniteBits VkPipelineCoverageToColorStateCreateFlagsNV
VkPipelineCoverageToColorStateCreateFlagsNV -> Int
forall b.
Bits b -> (b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
countTrailingZeros :: VkPipelineCoverageToColorStateCreateFlagsNV -> Int
$ccountTrailingZeros :: VkPipelineCoverageToColorStateCreateFlagsNV -> Int
countLeadingZeros :: VkPipelineCoverageToColorStateCreateFlagsNV -> Int
$ccountLeadingZeros :: VkPipelineCoverageToColorStateCreateFlagsNV -> Int
finiteBitSize :: VkPipelineCoverageToColorStateCreateFlagsNV -> Int
$cfiniteBitSize :: VkPipelineCoverageToColorStateCreateFlagsNV -> Int
FiniteBits,
                                                                Ptr VkPipelineCoverageToColorStateCreateFlagsNV
-> IO VkPipelineCoverageToColorStateCreateFlagsNV
Ptr VkPipelineCoverageToColorStateCreateFlagsNV
-> Int -> IO VkPipelineCoverageToColorStateCreateFlagsNV
Ptr VkPipelineCoverageToColorStateCreateFlagsNV
-> Int -> VkPipelineCoverageToColorStateCreateFlagsNV -> IO ()
Ptr VkPipelineCoverageToColorStateCreateFlagsNV
-> VkPipelineCoverageToColorStateCreateFlagsNV -> IO ()
VkPipelineCoverageToColorStateCreateFlagsNV -> Int
(VkPipelineCoverageToColorStateCreateFlagsNV -> Int)
-> (VkPipelineCoverageToColorStateCreateFlagsNV -> Int)
-> (Ptr VkPipelineCoverageToColorStateCreateFlagsNV
    -> Int -> IO VkPipelineCoverageToColorStateCreateFlagsNV)
-> (Ptr VkPipelineCoverageToColorStateCreateFlagsNV
    -> Int -> VkPipelineCoverageToColorStateCreateFlagsNV -> IO ())
-> (forall b.
    Ptr b -> Int -> IO VkPipelineCoverageToColorStateCreateFlagsNV)
-> (forall b.
    Ptr b
    -> Int -> VkPipelineCoverageToColorStateCreateFlagsNV -> IO ())
-> (Ptr VkPipelineCoverageToColorStateCreateFlagsNV
    -> IO VkPipelineCoverageToColorStateCreateFlagsNV)
-> (Ptr VkPipelineCoverageToColorStateCreateFlagsNV
    -> VkPipelineCoverageToColorStateCreateFlagsNV -> IO ())
-> Storable VkPipelineCoverageToColorStateCreateFlagsNV
forall b.
Ptr b -> Int -> IO VkPipelineCoverageToColorStateCreateFlagsNV
forall b.
Ptr b
-> Int -> VkPipelineCoverageToColorStateCreateFlagsNV -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr VkPipelineCoverageToColorStateCreateFlagsNV
-> VkPipelineCoverageToColorStateCreateFlagsNV -> IO ()
$cpoke :: Ptr VkPipelineCoverageToColorStateCreateFlagsNV
-> VkPipelineCoverageToColorStateCreateFlagsNV -> IO ()
peek :: Ptr VkPipelineCoverageToColorStateCreateFlagsNV
-> IO VkPipelineCoverageToColorStateCreateFlagsNV
$cpeek :: Ptr VkPipelineCoverageToColorStateCreateFlagsNV
-> IO VkPipelineCoverageToColorStateCreateFlagsNV
pokeByteOff :: forall b.
Ptr b
-> Int -> VkPipelineCoverageToColorStateCreateFlagsNV -> IO ()
$cpokeByteOff :: forall b.
Ptr b
-> Int -> VkPipelineCoverageToColorStateCreateFlagsNV -> IO ()
peekByteOff :: forall b.
Ptr b -> Int -> IO VkPipelineCoverageToColorStateCreateFlagsNV
$cpeekByteOff :: forall b.
Ptr b -> Int -> IO VkPipelineCoverageToColorStateCreateFlagsNV
pokeElemOff :: Ptr VkPipelineCoverageToColorStateCreateFlagsNV
-> Int -> VkPipelineCoverageToColorStateCreateFlagsNV -> IO ()
$cpokeElemOff :: Ptr VkPipelineCoverageToColorStateCreateFlagsNV
-> Int -> VkPipelineCoverageToColorStateCreateFlagsNV -> IO ()
peekElemOff :: Ptr VkPipelineCoverageToColorStateCreateFlagsNV
-> Int -> IO VkPipelineCoverageToColorStateCreateFlagsNV
$cpeekElemOff :: Ptr VkPipelineCoverageToColorStateCreateFlagsNV
-> Int -> IO VkPipelineCoverageToColorStateCreateFlagsNV
alignment :: VkPipelineCoverageToColorStateCreateFlagsNV -> Int
$calignment :: VkPipelineCoverageToColorStateCreateFlagsNV -> Int
sizeOf :: VkPipelineCoverageToColorStateCreateFlagsNV -> Int
$csizeOf :: VkPipelineCoverageToColorStateCreateFlagsNV -> Int
Storable)

instance Show VkPipelineCoverageToColorStateCreateFlagsNV where
    {-# INLINE showsPrec #-}
    showsPrec :: Int -> VkPipelineCoverageToColorStateCreateFlagsNV -> ShowS
showsPrec = (Int -> VkFlags -> ShowS)
-> Int -> VkPipelineCoverageToColorStateCreateFlagsNV -> ShowS
coerce (Int -> VkFlags -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec :: Int -> VkFlags -> ShowS)

instance Read VkPipelineCoverageToColorStateCreateFlagsNV where
    {-# INLINE readsPrec #-}
    readsPrec :: Int -> ReadS VkPipelineCoverageToColorStateCreateFlagsNV
readsPrec = (Int -> ReadS VkFlags)
-> Int -> ReadS VkPipelineCoverageToColorStateCreateFlagsNV
coerce (Int -> ReadS VkFlags
forall a. Read a => Int -> ReadS a
readsPrec :: Int -> ReadS VkFlags)

newtype VkPipelineDepthStencilStateCreateFlags = VkPipelineDepthStencilStateCreateFlags VkFlags
                                                 deriving (VkPipelineDepthStencilStateCreateFlags
-> VkPipelineDepthStencilStateCreateFlags -> Bool
(VkPipelineDepthStencilStateCreateFlags
 -> VkPipelineDepthStencilStateCreateFlags -> Bool)
-> (VkPipelineDepthStencilStateCreateFlags
    -> VkPipelineDepthStencilStateCreateFlags -> Bool)
-> Eq VkPipelineDepthStencilStateCreateFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VkPipelineDepthStencilStateCreateFlags
-> VkPipelineDepthStencilStateCreateFlags -> Bool
$c/= :: VkPipelineDepthStencilStateCreateFlags
-> VkPipelineDepthStencilStateCreateFlags -> Bool
== :: VkPipelineDepthStencilStateCreateFlags
-> VkPipelineDepthStencilStateCreateFlags -> Bool
$c== :: VkPipelineDepthStencilStateCreateFlags
-> VkPipelineDepthStencilStateCreateFlags -> Bool
Eq, Eq VkPipelineDepthStencilStateCreateFlags
Eq VkPipelineDepthStencilStateCreateFlags
-> (VkPipelineDepthStencilStateCreateFlags
    -> VkPipelineDepthStencilStateCreateFlags -> Ordering)
-> (VkPipelineDepthStencilStateCreateFlags
    -> VkPipelineDepthStencilStateCreateFlags -> Bool)
-> (VkPipelineDepthStencilStateCreateFlags
    -> VkPipelineDepthStencilStateCreateFlags -> Bool)
-> (VkPipelineDepthStencilStateCreateFlags
    -> VkPipelineDepthStencilStateCreateFlags -> Bool)
-> (VkPipelineDepthStencilStateCreateFlags
    -> VkPipelineDepthStencilStateCreateFlags -> Bool)
-> (VkPipelineDepthStencilStateCreateFlags
    -> VkPipelineDepthStencilStateCreateFlags
    -> VkPipelineDepthStencilStateCreateFlags)
-> (VkPipelineDepthStencilStateCreateFlags
    -> VkPipelineDepthStencilStateCreateFlags
    -> VkPipelineDepthStencilStateCreateFlags)
-> Ord VkPipelineDepthStencilStateCreateFlags
VkPipelineDepthStencilStateCreateFlags
-> VkPipelineDepthStencilStateCreateFlags -> Bool
VkPipelineDepthStencilStateCreateFlags
-> VkPipelineDepthStencilStateCreateFlags -> Ordering
VkPipelineDepthStencilStateCreateFlags
-> VkPipelineDepthStencilStateCreateFlags
-> VkPipelineDepthStencilStateCreateFlags
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: VkPipelineDepthStencilStateCreateFlags
-> VkPipelineDepthStencilStateCreateFlags
-> VkPipelineDepthStencilStateCreateFlags
$cmin :: VkPipelineDepthStencilStateCreateFlags
-> VkPipelineDepthStencilStateCreateFlags
-> VkPipelineDepthStencilStateCreateFlags
max :: VkPipelineDepthStencilStateCreateFlags
-> VkPipelineDepthStencilStateCreateFlags
-> VkPipelineDepthStencilStateCreateFlags
$cmax :: VkPipelineDepthStencilStateCreateFlags
-> VkPipelineDepthStencilStateCreateFlags
-> VkPipelineDepthStencilStateCreateFlags
>= :: VkPipelineDepthStencilStateCreateFlags
-> VkPipelineDepthStencilStateCreateFlags -> Bool
$c>= :: VkPipelineDepthStencilStateCreateFlags
-> VkPipelineDepthStencilStateCreateFlags -> Bool
> :: VkPipelineDepthStencilStateCreateFlags
-> VkPipelineDepthStencilStateCreateFlags -> Bool
$c> :: VkPipelineDepthStencilStateCreateFlags
-> VkPipelineDepthStencilStateCreateFlags -> Bool
<= :: VkPipelineDepthStencilStateCreateFlags
-> VkPipelineDepthStencilStateCreateFlags -> Bool
$c<= :: VkPipelineDepthStencilStateCreateFlags
-> VkPipelineDepthStencilStateCreateFlags -> Bool
< :: VkPipelineDepthStencilStateCreateFlags
-> VkPipelineDepthStencilStateCreateFlags -> Bool
$c< :: VkPipelineDepthStencilStateCreateFlags
-> VkPipelineDepthStencilStateCreateFlags -> Bool
compare :: VkPipelineDepthStencilStateCreateFlags
-> VkPipelineDepthStencilStateCreateFlags -> Ordering
$ccompare :: VkPipelineDepthStencilStateCreateFlags
-> VkPipelineDepthStencilStateCreateFlags -> Ordering
Ord, Int -> VkPipelineDepthStencilStateCreateFlags
VkPipelineDepthStencilStateCreateFlags -> Int
VkPipelineDepthStencilStateCreateFlags
-> [VkPipelineDepthStencilStateCreateFlags]
VkPipelineDepthStencilStateCreateFlags
-> VkPipelineDepthStencilStateCreateFlags
VkPipelineDepthStencilStateCreateFlags
-> VkPipelineDepthStencilStateCreateFlags
-> [VkPipelineDepthStencilStateCreateFlags]
VkPipelineDepthStencilStateCreateFlags
-> VkPipelineDepthStencilStateCreateFlags
-> VkPipelineDepthStencilStateCreateFlags
-> [VkPipelineDepthStencilStateCreateFlags]
(VkPipelineDepthStencilStateCreateFlags
 -> VkPipelineDepthStencilStateCreateFlags)
-> (VkPipelineDepthStencilStateCreateFlags
    -> VkPipelineDepthStencilStateCreateFlags)
-> (Int -> VkPipelineDepthStencilStateCreateFlags)
-> (VkPipelineDepthStencilStateCreateFlags -> Int)
-> (VkPipelineDepthStencilStateCreateFlags
    -> [VkPipelineDepthStencilStateCreateFlags])
-> (VkPipelineDepthStencilStateCreateFlags
    -> VkPipelineDepthStencilStateCreateFlags
    -> [VkPipelineDepthStencilStateCreateFlags])
-> (VkPipelineDepthStencilStateCreateFlags
    -> VkPipelineDepthStencilStateCreateFlags
    -> [VkPipelineDepthStencilStateCreateFlags])
-> (VkPipelineDepthStencilStateCreateFlags
    -> VkPipelineDepthStencilStateCreateFlags
    -> VkPipelineDepthStencilStateCreateFlags
    -> [VkPipelineDepthStencilStateCreateFlags])
-> Enum VkPipelineDepthStencilStateCreateFlags
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: VkPipelineDepthStencilStateCreateFlags
-> VkPipelineDepthStencilStateCreateFlags
-> VkPipelineDepthStencilStateCreateFlags
-> [VkPipelineDepthStencilStateCreateFlags]
$cenumFromThenTo :: VkPipelineDepthStencilStateCreateFlags
-> VkPipelineDepthStencilStateCreateFlags
-> VkPipelineDepthStencilStateCreateFlags
-> [VkPipelineDepthStencilStateCreateFlags]
enumFromTo :: VkPipelineDepthStencilStateCreateFlags
-> VkPipelineDepthStencilStateCreateFlags
-> [VkPipelineDepthStencilStateCreateFlags]
$cenumFromTo :: VkPipelineDepthStencilStateCreateFlags
-> VkPipelineDepthStencilStateCreateFlags
-> [VkPipelineDepthStencilStateCreateFlags]
enumFromThen :: VkPipelineDepthStencilStateCreateFlags
-> VkPipelineDepthStencilStateCreateFlags
-> [VkPipelineDepthStencilStateCreateFlags]
$cenumFromThen :: VkPipelineDepthStencilStateCreateFlags
-> VkPipelineDepthStencilStateCreateFlags
-> [VkPipelineDepthStencilStateCreateFlags]
enumFrom :: VkPipelineDepthStencilStateCreateFlags
-> [VkPipelineDepthStencilStateCreateFlags]
$cenumFrom :: VkPipelineDepthStencilStateCreateFlags
-> [VkPipelineDepthStencilStateCreateFlags]
fromEnum :: VkPipelineDepthStencilStateCreateFlags -> Int
$cfromEnum :: VkPipelineDepthStencilStateCreateFlags -> Int
toEnum :: Int -> VkPipelineDepthStencilStateCreateFlags
$ctoEnum :: Int -> VkPipelineDepthStencilStateCreateFlags
pred :: VkPipelineDepthStencilStateCreateFlags
-> VkPipelineDepthStencilStateCreateFlags
$cpred :: VkPipelineDepthStencilStateCreateFlags
-> VkPipelineDepthStencilStateCreateFlags
succ :: VkPipelineDepthStencilStateCreateFlags
-> VkPipelineDepthStencilStateCreateFlags
$csucc :: VkPipelineDepthStencilStateCreateFlags
-> VkPipelineDepthStencilStateCreateFlags
Enum, Eq VkPipelineDepthStencilStateCreateFlags
VkPipelineDepthStencilStateCreateFlags
Eq VkPipelineDepthStencilStateCreateFlags
-> (VkPipelineDepthStencilStateCreateFlags
    -> VkPipelineDepthStencilStateCreateFlags
    -> VkPipelineDepthStencilStateCreateFlags)
-> (VkPipelineDepthStencilStateCreateFlags
    -> VkPipelineDepthStencilStateCreateFlags
    -> VkPipelineDepthStencilStateCreateFlags)
-> (VkPipelineDepthStencilStateCreateFlags
    -> VkPipelineDepthStencilStateCreateFlags
    -> VkPipelineDepthStencilStateCreateFlags)
-> (VkPipelineDepthStencilStateCreateFlags
    -> VkPipelineDepthStencilStateCreateFlags)
-> (VkPipelineDepthStencilStateCreateFlags
    -> Int -> VkPipelineDepthStencilStateCreateFlags)
-> (VkPipelineDepthStencilStateCreateFlags
    -> Int -> VkPipelineDepthStencilStateCreateFlags)
-> VkPipelineDepthStencilStateCreateFlags
-> (Int -> VkPipelineDepthStencilStateCreateFlags)
-> (VkPipelineDepthStencilStateCreateFlags
    -> Int -> VkPipelineDepthStencilStateCreateFlags)
-> (VkPipelineDepthStencilStateCreateFlags
    -> Int -> VkPipelineDepthStencilStateCreateFlags)
-> (VkPipelineDepthStencilStateCreateFlags
    -> Int -> VkPipelineDepthStencilStateCreateFlags)
-> (VkPipelineDepthStencilStateCreateFlags -> Int -> Bool)
-> (VkPipelineDepthStencilStateCreateFlags -> Maybe Int)
-> (VkPipelineDepthStencilStateCreateFlags -> Int)
-> (VkPipelineDepthStencilStateCreateFlags -> Bool)
-> (VkPipelineDepthStencilStateCreateFlags
    -> Int -> VkPipelineDepthStencilStateCreateFlags)
-> (VkPipelineDepthStencilStateCreateFlags
    -> Int -> VkPipelineDepthStencilStateCreateFlags)
-> (VkPipelineDepthStencilStateCreateFlags
    -> Int -> VkPipelineDepthStencilStateCreateFlags)
-> (VkPipelineDepthStencilStateCreateFlags
    -> Int -> VkPipelineDepthStencilStateCreateFlags)
-> (VkPipelineDepthStencilStateCreateFlags
    -> Int -> VkPipelineDepthStencilStateCreateFlags)
-> (VkPipelineDepthStencilStateCreateFlags
    -> Int -> VkPipelineDepthStencilStateCreateFlags)
-> (VkPipelineDepthStencilStateCreateFlags -> Int)
-> Bits VkPipelineDepthStencilStateCreateFlags
Int -> VkPipelineDepthStencilStateCreateFlags
VkPipelineDepthStencilStateCreateFlags -> Bool
VkPipelineDepthStencilStateCreateFlags -> Int
VkPipelineDepthStencilStateCreateFlags -> Maybe Int
VkPipelineDepthStencilStateCreateFlags
-> VkPipelineDepthStencilStateCreateFlags
VkPipelineDepthStencilStateCreateFlags -> Int -> Bool
VkPipelineDepthStencilStateCreateFlags
-> Int -> VkPipelineDepthStencilStateCreateFlags
VkPipelineDepthStencilStateCreateFlags
-> VkPipelineDepthStencilStateCreateFlags
-> VkPipelineDepthStencilStateCreateFlags
forall a.
Eq a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
popCount :: VkPipelineDepthStencilStateCreateFlags -> Int
$cpopCount :: VkPipelineDepthStencilStateCreateFlags -> Int
rotateR :: VkPipelineDepthStencilStateCreateFlags
-> Int -> VkPipelineDepthStencilStateCreateFlags
$crotateR :: VkPipelineDepthStencilStateCreateFlags
-> Int -> VkPipelineDepthStencilStateCreateFlags
rotateL :: VkPipelineDepthStencilStateCreateFlags
-> Int -> VkPipelineDepthStencilStateCreateFlags
$crotateL :: VkPipelineDepthStencilStateCreateFlags
-> Int -> VkPipelineDepthStencilStateCreateFlags
unsafeShiftR :: VkPipelineDepthStencilStateCreateFlags
-> Int -> VkPipelineDepthStencilStateCreateFlags
$cunsafeShiftR :: VkPipelineDepthStencilStateCreateFlags
-> Int -> VkPipelineDepthStencilStateCreateFlags
shiftR :: VkPipelineDepthStencilStateCreateFlags
-> Int -> VkPipelineDepthStencilStateCreateFlags
$cshiftR :: VkPipelineDepthStencilStateCreateFlags
-> Int -> VkPipelineDepthStencilStateCreateFlags
unsafeShiftL :: VkPipelineDepthStencilStateCreateFlags
-> Int -> VkPipelineDepthStencilStateCreateFlags
$cunsafeShiftL :: VkPipelineDepthStencilStateCreateFlags
-> Int -> VkPipelineDepthStencilStateCreateFlags
shiftL :: VkPipelineDepthStencilStateCreateFlags
-> Int -> VkPipelineDepthStencilStateCreateFlags
$cshiftL :: VkPipelineDepthStencilStateCreateFlags
-> Int -> VkPipelineDepthStencilStateCreateFlags
isSigned :: VkPipelineDepthStencilStateCreateFlags -> Bool
$cisSigned :: VkPipelineDepthStencilStateCreateFlags -> Bool
bitSize :: VkPipelineDepthStencilStateCreateFlags -> Int
$cbitSize :: VkPipelineDepthStencilStateCreateFlags -> Int
bitSizeMaybe :: VkPipelineDepthStencilStateCreateFlags -> Maybe Int
$cbitSizeMaybe :: VkPipelineDepthStencilStateCreateFlags -> Maybe Int
testBit :: VkPipelineDepthStencilStateCreateFlags -> Int -> Bool
$ctestBit :: VkPipelineDepthStencilStateCreateFlags -> Int -> Bool
complementBit :: VkPipelineDepthStencilStateCreateFlags
-> Int -> VkPipelineDepthStencilStateCreateFlags
$ccomplementBit :: VkPipelineDepthStencilStateCreateFlags
-> Int -> VkPipelineDepthStencilStateCreateFlags
clearBit :: VkPipelineDepthStencilStateCreateFlags
-> Int -> VkPipelineDepthStencilStateCreateFlags
$cclearBit :: VkPipelineDepthStencilStateCreateFlags
-> Int -> VkPipelineDepthStencilStateCreateFlags
setBit :: VkPipelineDepthStencilStateCreateFlags
-> Int -> VkPipelineDepthStencilStateCreateFlags
$csetBit :: VkPipelineDepthStencilStateCreateFlags
-> Int -> VkPipelineDepthStencilStateCreateFlags
bit :: Int -> VkPipelineDepthStencilStateCreateFlags
$cbit :: Int -> VkPipelineDepthStencilStateCreateFlags
zeroBits :: VkPipelineDepthStencilStateCreateFlags
$czeroBits :: VkPipelineDepthStencilStateCreateFlags
rotate :: VkPipelineDepthStencilStateCreateFlags
-> Int -> VkPipelineDepthStencilStateCreateFlags
$crotate :: VkPipelineDepthStencilStateCreateFlags
-> Int -> VkPipelineDepthStencilStateCreateFlags
shift :: VkPipelineDepthStencilStateCreateFlags
-> Int -> VkPipelineDepthStencilStateCreateFlags
$cshift :: VkPipelineDepthStencilStateCreateFlags
-> Int -> VkPipelineDepthStencilStateCreateFlags
complement :: VkPipelineDepthStencilStateCreateFlags
-> VkPipelineDepthStencilStateCreateFlags
$ccomplement :: VkPipelineDepthStencilStateCreateFlags
-> VkPipelineDepthStencilStateCreateFlags
xor :: VkPipelineDepthStencilStateCreateFlags
-> VkPipelineDepthStencilStateCreateFlags
-> VkPipelineDepthStencilStateCreateFlags
$cxor :: VkPipelineDepthStencilStateCreateFlags
-> VkPipelineDepthStencilStateCreateFlags
-> VkPipelineDepthStencilStateCreateFlags
.|. :: VkPipelineDepthStencilStateCreateFlags
-> VkPipelineDepthStencilStateCreateFlags
-> VkPipelineDepthStencilStateCreateFlags
$c.|. :: VkPipelineDepthStencilStateCreateFlags
-> VkPipelineDepthStencilStateCreateFlags
-> VkPipelineDepthStencilStateCreateFlags
.&. :: VkPipelineDepthStencilStateCreateFlags
-> VkPipelineDepthStencilStateCreateFlags
-> VkPipelineDepthStencilStateCreateFlags
$c.&. :: VkPipelineDepthStencilStateCreateFlags
-> VkPipelineDepthStencilStateCreateFlags
-> VkPipelineDepthStencilStateCreateFlags
Bits, Bits VkPipelineDepthStencilStateCreateFlags
Bits VkPipelineDepthStencilStateCreateFlags
-> (VkPipelineDepthStencilStateCreateFlags -> Int)
-> (VkPipelineDepthStencilStateCreateFlags -> Int)
-> (VkPipelineDepthStencilStateCreateFlags -> Int)
-> FiniteBits VkPipelineDepthStencilStateCreateFlags
VkPipelineDepthStencilStateCreateFlags -> Int
forall b.
Bits b -> (b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
countTrailingZeros :: VkPipelineDepthStencilStateCreateFlags -> Int
$ccountTrailingZeros :: VkPipelineDepthStencilStateCreateFlags -> Int
countLeadingZeros :: VkPipelineDepthStencilStateCreateFlags -> Int
$ccountLeadingZeros :: VkPipelineDepthStencilStateCreateFlags -> Int
finiteBitSize :: VkPipelineDepthStencilStateCreateFlags -> Int
$cfiniteBitSize :: VkPipelineDepthStencilStateCreateFlags -> Int
FiniteBits,
                                                           Ptr VkPipelineDepthStencilStateCreateFlags
-> IO VkPipelineDepthStencilStateCreateFlags
Ptr VkPipelineDepthStencilStateCreateFlags
-> Int -> IO VkPipelineDepthStencilStateCreateFlags
Ptr VkPipelineDepthStencilStateCreateFlags
-> Int -> VkPipelineDepthStencilStateCreateFlags -> IO ()
Ptr VkPipelineDepthStencilStateCreateFlags
-> VkPipelineDepthStencilStateCreateFlags -> IO ()
VkPipelineDepthStencilStateCreateFlags -> Int
(VkPipelineDepthStencilStateCreateFlags -> Int)
-> (VkPipelineDepthStencilStateCreateFlags -> Int)
-> (Ptr VkPipelineDepthStencilStateCreateFlags
    -> Int -> IO VkPipelineDepthStencilStateCreateFlags)
-> (Ptr VkPipelineDepthStencilStateCreateFlags
    -> Int -> VkPipelineDepthStencilStateCreateFlags -> IO ())
-> (forall b.
    Ptr b -> Int -> IO VkPipelineDepthStencilStateCreateFlags)
-> (forall b.
    Ptr b -> Int -> VkPipelineDepthStencilStateCreateFlags -> IO ())
-> (Ptr VkPipelineDepthStencilStateCreateFlags
    -> IO VkPipelineDepthStencilStateCreateFlags)
-> (Ptr VkPipelineDepthStencilStateCreateFlags
    -> VkPipelineDepthStencilStateCreateFlags -> IO ())
-> Storable VkPipelineDepthStencilStateCreateFlags
forall b. Ptr b -> Int -> IO VkPipelineDepthStencilStateCreateFlags
forall b.
Ptr b -> Int -> VkPipelineDepthStencilStateCreateFlags -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr VkPipelineDepthStencilStateCreateFlags
-> VkPipelineDepthStencilStateCreateFlags -> IO ()
$cpoke :: Ptr VkPipelineDepthStencilStateCreateFlags
-> VkPipelineDepthStencilStateCreateFlags -> IO ()
peek :: Ptr VkPipelineDepthStencilStateCreateFlags
-> IO VkPipelineDepthStencilStateCreateFlags
$cpeek :: Ptr VkPipelineDepthStencilStateCreateFlags
-> IO VkPipelineDepthStencilStateCreateFlags
pokeByteOff :: forall b.
Ptr b -> Int -> VkPipelineDepthStencilStateCreateFlags -> IO ()
$cpokeByteOff :: forall b.
Ptr b -> Int -> VkPipelineDepthStencilStateCreateFlags -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO VkPipelineDepthStencilStateCreateFlags
$cpeekByteOff :: forall b. Ptr b -> Int -> IO VkPipelineDepthStencilStateCreateFlags
pokeElemOff :: Ptr VkPipelineDepthStencilStateCreateFlags
-> Int -> VkPipelineDepthStencilStateCreateFlags -> IO ()
$cpokeElemOff :: Ptr VkPipelineDepthStencilStateCreateFlags
-> Int -> VkPipelineDepthStencilStateCreateFlags -> IO ()
peekElemOff :: Ptr VkPipelineDepthStencilStateCreateFlags
-> Int -> IO VkPipelineDepthStencilStateCreateFlags
$cpeekElemOff :: Ptr VkPipelineDepthStencilStateCreateFlags
-> Int -> IO VkPipelineDepthStencilStateCreateFlags
alignment :: VkPipelineDepthStencilStateCreateFlags -> Int
$calignment :: VkPipelineDepthStencilStateCreateFlags -> Int
sizeOf :: VkPipelineDepthStencilStateCreateFlags -> Int
$csizeOf :: VkPipelineDepthStencilStateCreateFlags -> Int
Storable)

instance Show VkPipelineDepthStencilStateCreateFlags where
    {-# INLINE showsPrec #-}
    showsPrec :: Int -> VkPipelineDepthStencilStateCreateFlags -> ShowS
showsPrec = (Int -> VkFlags -> ShowS)
-> Int -> VkPipelineDepthStencilStateCreateFlags -> ShowS
coerce (Int -> VkFlags -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec :: Int -> VkFlags -> ShowS)

instance Read VkPipelineDepthStencilStateCreateFlags where
    {-# INLINE readsPrec #-}
    readsPrec :: Int -> ReadS VkPipelineDepthStencilStateCreateFlags
readsPrec = (Int -> ReadS VkFlags)
-> Int -> ReadS VkPipelineDepthStencilStateCreateFlags
coerce (Int -> ReadS VkFlags
forall a. Read a => Int -> ReadS a
readsPrec :: Int -> ReadS VkFlags)

newtype VkPipelineDiscardRectangleStateCreateFlagsEXT = VkPipelineDiscardRectangleStateCreateFlagsEXT VkFlags
                                                        deriving (VkPipelineDiscardRectangleStateCreateFlagsEXT
-> VkPipelineDiscardRectangleStateCreateFlagsEXT -> Bool
(VkPipelineDiscardRectangleStateCreateFlagsEXT
 -> VkPipelineDiscardRectangleStateCreateFlagsEXT -> Bool)
-> (VkPipelineDiscardRectangleStateCreateFlagsEXT
    -> VkPipelineDiscardRectangleStateCreateFlagsEXT -> Bool)
-> Eq VkPipelineDiscardRectangleStateCreateFlagsEXT
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VkPipelineDiscardRectangleStateCreateFlagsEXT
-> VkPipelineDiscardRectangleStateCreateFlagsEXT -> Bool
$c/= :: VkPipelineDiscardRectangleStateCreateFlagsEXT
-> VkPipelineDiscardRectangleStateCreateFlagsEXT -> Bool
== :: VkPipelineDiscardRectangleStateCreateFlagsEXT
-> VkPipelineDiscardRectangleStateCreateFlagsEXT -> Bool
$c== :: VkPipelineDiscardRectangleStateCreateFlagsEXT
-> VkPipelineDiscardRectangleStateCreateFlagsEXT -> Bool
Eq, Eq VkPipelineDiscardRectangleStateCreateFlagsEXT
Eq VkPipelineDiscardRectangleStateCreateFlagsEXT
-> (VkPipelineDiscardRectangleStateCreateFlagsEXT
    -> VkPipelineDiscardRectangleStateCreateFlagsEXT -> Ordering)
-> (VkPipelineDiscardRectangleStateCreateFlagsEXT
    -> VkPipelineDiscardRectangleStateCreateFlagsEXT -> Bool)
-> (VkPipelineDiscardRectangleStateCreateFlagsEXT
    -> VkPipelineDiscardRectangleStateCreateFlagsEXT -> Bool)
-> (VkPipelineDiscardRectangleStateCreateFlagsEXT
    -> VkPipelineDiscardRectangleStateCreateFlagsEXT -> Bool)
-> (VkPipelineDiscardRectangleStateCreateFlagsEXT
    -> VkPipelineDiscardRectangleStateCreateFlagsEXT -> Bool)
-> (VkPipelineDiscardRectangleStateCreateFlagsEXT
    -> VkPipelineDiscardRectangleStateCreateFlagsEXT
    -> VkPipelineDiscardRectangleStateCreateFlagsEXT)
-> (VkPipelineDiscardRectangleStateCreateFlagsEXT
    -> VkPipelineDiscardRectangleStateCreateFlagsEXT
    -> VkPipelineDiscardRectangleStateCreateFlagsEXT)
-> Ord VkPipelineDiscardRectangleStateCreateFlagsEXT
VkPipelineDiscardRectangleStateCreateFlagsEXT
-> VkPipelineDiscardRectangleStateCreateFlagsEXT -> Bool
VkPipelineDiscardRectangleStateCreateFlagsEXT
-> VkPipelineDiscardRectangleStateCreateFlagsEXT -> Ordering
VkPipelineDiscardRectangleStateCreateFlagsEXT
-> VkPipelineDiscardRectangleStateCreateFlagsEXT
-> VkPipelineDiscardRectangleStateCreateFlagsEXT
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: VkPipelineDiscardRectangleStateCreateFlagsEXT
-> VkPipelineDiscardRectangleStateCreateFlagsEXT
-> VkPipelineDiscardRectangleStateCreateFlagsEXT
$cmin :: VkPipelineDiscardRectangleStateCreateFlagsEXT
-> VkPipelineDiscardRectangleStateCreateFlagsEXT
-> VkPipelineDiscardRectangleStateCreateFlagsEXT
max :: VkPipelineDiscardRectangleStateCreateFlagsEXT
-> VkPipelineDiscardRectangleStateCreateFlagsEXT
-> VkPipelineDiscardRectangleStateCreateFlagsEXT
$cmax :: VkPipelineDiscardRectangleStateCreateFlagsEXT
-> VkPipelineDiscardRectangleStateCreateFlagsEXT
-> VkPipelineDiscardRectangleStateCreateFlagsEXT
>= :: VkPipelineDiscardRectangleStateCreateFlagsEXT
-> VkPipelineDiscardRectangleStateCreateFlagsEXT -> Bool
$c>= :: VkPipelineDiscardRectangleStateCreateFlagsEXT
-> VkPipelineDiscardRectangleStateCreateFlagsEXT -> Bool
> :: VkPipelineDiscardRectangleStateCreateFlagsEXT
-> VkPipelineDiscardRectangleStateCreateFlagsEXT -> Bool
$c> :: VkPipelineDiscardRectangleStateCreateFlagsEXT
-> VkPipelineDiscardRectangleStateCreateFlagsEXT -> Bool
<= :: VkPipelineDiscardRectangleStateCreateFlagsEXT
-> VkPipelineDiscardRectangleStateCreateFlagsEXT -> Bool
$c<= :: VkPipelineDiscardRectangleStateCreateFlagsEXT
-> VkPipelineDiscardRectangleStateCreateFlagsEXT -> Bool
< :: VkPipelineDiscardRectangleStateCreateFlagsEXT
-> VkPipelineDiscardRectangleStateCreateFlagsEXT -> Bool
$c< :: VkPipelineDiscardRectangleStateCreateFlagsEXT
-> VkPipelineDiscardRectangleStateCreateFlagsEXT -> Bool
compare :: VkPipelineDiscardRectangleStateCreateFlagsEXT
-> VkPipelineDiscardRectangleStateCreateFlagsEXT -> Ordering
$ccompare :: VkPipelineDiscardRectangleStateCreateFlagsEXT
-> VkPipelineDiscardRectangleStateCreateFlagsEXT -> Ordering
Ord, Int -> VkPipelineDiscardRectangleStateCreateFlagsEXT
VkPipelineDiscardRectangleStateCreateFlagsEXT -> Int
VkPipelineDiscardRectangleStateCreateFlagsEXT
-> [VkPipelineDiscardRectangleStateCreateFlagsEXT]
VkPipelineDiscardRectangleStateCreateFlagsEXT
-> VkPipelineDiscardRectangleStateCreateFlagsEXT
VkPipelineDiscardRectangleStateCreateFlagsEXT
-> VkPipelineDiscardRectangleStateCreateFlagsEXT
-> [VkPipelineDiscardRectangleStateCreateFlagsEXT]
VkPipelineDiscardRectangleStateCreateFlagsEXT
-> VkPipelineDiscardRectangleStateCreateFlagsEXT
-> VkPipelineDiscardRectangleStateCreateFlagsEXT
-> [VkPipelineDiscardRectangleStateCreateFlagsEXT]
(VkPipelineDiscardRectangleStateCreateFlagsEXT
 -> VkPipelineDiscardRectangleStateCreateFlagsEXT)
-> (VkPipelineDiscardRectangleStateCreateFlagsEXT
    -> VkPipelineDiscardRectangleStateCreateFlagsEXT)
-> (Int -> VkPipelineDiscardRectangleStateCreateFlagsEXT)
-> (VkPipelineDiscardRectangleStateCreateFlagsEXT -> Int)
-> (VkPipelineDiscardRectangleStateCreateFlagsEXT
    -> [VkPipelineDiscardRectangleStateCreateFlagsEXT])
-> (VkPipelineDiscardRectangleStateCreateFlagsEXT
    -> VkPipelineDiscardRectangleStateCreateFlagsEXT
    -> [VkPipelineDiscardRectangleStateCreateFlagsEXT])
-> (VkPipelineDiscardRectangleStateCreateFlagsEXT
    -> VkPipelineDiscardRectangleStateCreateFlagsEXT
    -> [VkPipelineDiscardRectangleStateCreateFlagsEXT])
-> (VkPipelineDiscardRectangleStateCreateFlagsEXT
    -> VkPipelineDiscardRectangleStateCreateFlagsEXT
    -> VkPipelineDiscardRectangleStateCreateFlagsEXT
    -> [VkPipelineDiscardRectangleStateCreateFlagsEXT])
-> Enum VkPipelineDiscardRectangleStateCreateFlagsEXT
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: VkPipelineDiscardRectangleStateCreateFlagsEXT
-> VkPipelineDiscardRectangleStateCreateFlagsEXT
-> VkPipelineDiscardRectangleStateCreateFlagsEXT
-> [VkPipelineDiscardRectangleStateCreateFlagsEXT]
$cenumFromThenTo :: VkPipelineDiscardRectangleStateCreateFlagsEXT
-> VkPipelineDiscardRectangleStateCreateFlagsEXT
-> VkPipelineDiscardRectangleStateCreateFlagsEXT
-> [VkPipelineDiscardRectangleStateCreateFlagsEXT]
enumFromTo :: VkPipelineDiscardRectangleStateCreateFlagsEXT
-> VkPipelineDiscardRectangleStateCreateFlagsEXT
-> [VkPipelineDiscardRectangleStateCreateFlagsEXT]
$cenumFromTo :: VkPipelineDiscardRectangleStateCreateFlagsEXT
-> VkPipelineDiscardRectangleStateCreateFlagsEXT
-> [VkPipelineDiscardRectangleStateCreateFlagsEXT]
enumFromThen :: VkPipelineDiscardRectangleStateCreateFlagsEXT
-> VkPipelineDiscardRectangleStateCreateFlagsEXT
-> [VkPipelineDiscardRectangleStateCreateFlagsEXT]
$cenumFromThen :: VkPipelineDiscardRectangleStateCreateFlagsEXT
-> VkPipelineDiscardRectangleStateCreateFlagsEXT
-> [VkPipelineDiscardRectangleStateCreateFlagsEXT]
enumFrom :: VkPipelineDiscardRectangleStateCreateFlagsEXT
-> [VkPipelineDiscardRectangleStateCreateFlagsEXT]
$cenumFrom :: VkPipelineDiscardRectangleStateCreateFlagsEXT
-> [VkPipelineDiscardRectangleStateCreateFlagsEXT]
fromEnum :: VkPipelineDiscardRectangleStateCreateFlagsEXT -> Int
$cfromEnum :: VkPipelineDiscardRectangleStateCreateFlagsEXT -> Int
toEnum :: Int -> VkPipelineDiscardRectangleStateCreateFlagsEXT
$ctoEnum :: Int -> VkPipelineDiscardRectangleStateCreateFlagsEXT
pred :: VkPipelineDiscardRectangleStateCreateFlagsEXT
-> VkPipelineDiscardRectangleStateCreateFlagsEXT
$cpred :: VkPipelineDiscardRectangleStateCreateFlagsEXT
-> VkPipelineDiscardRectangleStateCreateFlagsEXT
succ :: VkPipelineDiscardRectangleStateCreateFlagsEXT
-> VkPipelineDiscardRectangleStateCreateFlagsEXT
$csucc :: VkPipelineDiscardRectangleStateCreateFlagsEXT
-> VkPipelineDiscardRectangleStateCreateFlagsEXT
Enum, Eq VkPipelineDiscardRectangleStateCreateFlagsEXT
VkPipelineDiscardRectangleStateCreateFlagsEXT
Eq VkPipelineDiscardRectangleStateCreateFlagsEXT
-> (VkPipelineDiscardRectangleStateCreateFlagsEXT
    -> VkPipelineDiscardRectangleStateCreateFlagsEXT
    -> VkPipelineDiscardRectangleStateCreateFlagsEXT)
-> (VkPipelineDiscardRectangleStateCreateFlagsEXT
    -> VkPipelineDiscardRectangleStateCreateFlagsEXT
    -> VkPipelineDiscardRectangleStateCreateFlagsEXT)
-> (VkPipelineDiscardRectangleStateCreateFlagsEXT
    -> VkPipelineDiscardRectangleStateCreateFlagsEXT
    -> VkPipelineDiscardRectangleStateCreateFlagsEXT)
-> (VkPipelineDiscardRectangleStateCreateFlagsEXT
    -> VkPipelineDiscardRectangleStateCreateFlagsEXT)
-> (VkPipelineDiscardRectangleStateCreateFlagsEXT
    -> Int -> VkPipelineDiscardRectangleStateCreateFlagsEXT)
-> (VkPipelineDiscardRectangleStateCreateFlagsEXT
    -> Int -> VkPipelineDiscardRectangleStateCreateFlagsEXT)
-> VkPipelineDiscardRectangleStateCreateFlagsEXT
-> (Int -> VkPipelineDiscardRectangleStateCreateFlagsEXT)
-> (VkPipelineDiscardRectangleStateCreateFlagsEXT
    -> Int -> VkPipelineDiscardRectangleStateCreateFlagsEXT)
-> (VkPipelineDiscardRectangleStateCreateFlagsEXT
    -> Int -> VkPipelineDiscardRectangleStateCreateFlagsEXT)
-> (VkPipelineDiscardRectangleStateCreateFlagsEXT
    -> Int -> VkPipelineDiscardRectangleStateCreateFlagsEXT)
-> (VkPipelineDiscardRectangleStateCreateFlagsEXT -> Int -> Bool)
-> (VkPipelineDiscardRectangleStateCreateFlagsEXT -> Maybe Int)
-> (VkPipelineDiscardRectangleStateCreateFlagsEXT -> Int)
-> (VkPipelineDiscardRectangleStateCreateFlagsEXT -> Bool)
-> (VkPipelineDiscardRectangleStateCreateFlagsEXT
    -> Int -> VkPipelineDiscardRectangleStateCreateFlagsEXT)
-> (VkPipelineDiscardRectangleStateCreateFlagsEXT
    -> Int -> VkPipelineDiscardRectangleStateCreateFlagsEXT)
-> (VkPipelineDiscardRectangleStateCreateFlagsEXT
    -> Int -> VkPipelineDiscardRectangleStateCreateFlagsEXT)
-> (VkPipelineDiscardRectangleStateCreateFlagsEXT
    -> Int -> VkPipelineDiscardRectangleStateCreateFlagsEXT)
-> (VkPipelineDiscardRectangleStateCreateFlagsEXT
    -> Int -> VkPipelineDiscardRectangleStateCreateFlagsEXT)
-> (VkPipelineDiscardRectangleStateCreateFlagsEXT
    -> Int -> VkPipelineDiscardRectangleStateCreateFlagsEXT)
-> (VkPipelineDiscardRectangleStateCreateFlagsEXT -> Int)
-> Bits VkPipelineDiscardRectangleStateCreateFlagsEXT
Int -> VkPipelineDiscardRectangleStateCreateFlagsEXT
VkPipelineDiscardRectangleStateCreateFlagsEXT -> Bool
VkPipelineDiscardRectangleStateCreateFlagsEXT -> Int
VkPipelineDiscardRectangleStateCreateFlagsEXT -> Maybe Int
VkPipelineDiscardRectangleStateCreateFlagsEXT
-> VkPipelineDiscardRectangleStateCreateFlagsEXT
VkPipelineDiscardRectangleStateCreateFlagsEXT -> Int -> Bool
VkPipelineDiscardRectangleStateCreateFlagsEXT
-> Int -> VkPipelineDiscardRectangleStateCreateFlagsEXT
VkPipelineDiscardRectangleStateCreateFlagsEXT
-> VkPipelineDiscardRectangleStateCreateFlagsEXT
-> VkPipelineDiscardRectangleStateCreateFlagsEXT
forall a.
Eq a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
popCount :: VkPipelineDiscardRectangleStateCreateFlagsEXT -> Int
$cpopCount :: VkPipelineDiscardRectangleStateCreateFlagsEXT -> Int
rotateR :: VkPipelineDiscardRectangleStateCreateFlagsEXT
-> Int -> VkPipelineDiscardRectangleStateCreateFlagsEXT
$crotateR :: VkPipelineDiscardRectangleStateCreateFlagsEXT
-> Int -> VkPipelineDiscardRectangleStateCreateFlagsEXT
rotateL :: VkPipelineDiscardRectangleStateCreateFlagsEXT
-> Int -> VkPipelineDiscardRectangleStateCreateFlagsEXT
$crotateL :: VkPipelineDiscardRectangleStateCreateFlagsEXT
-> Int -> VkPipelineDiscardRectangleStateCreateFlagsEXT
unsafeShiftR :: VkPipelineDiscardRectangleStateCreateFlagsEXT
-> Int -> VkPipelineDiscardRectangleStateCreateFlagsEXT
$cunsafeShiftR :: VkPipelineDiscardRectangleStateCreateFlagsEXT
-> Int -> VkPipelineDiscardRectangleStateCreateFlagsEXT
shiftR :: VkPipelineDiscardRectangleStateCreateFlagsEXT
-> Int -> VkPipelineDiscardRectangleStateCreateFlagsEXT
$cshiftR :: VkPipelineDiscardRectangleStateCreateFlagsEXT
-> Int -> VkPipelineDiscardRectangleStateCreateFlagsEXT
unsafeShiftL :: VkPipelineDiscardRectangleStateCreateFlagsEXT
-> Int -> VkPipelineDiscardRectangleStateCreateFlagsEXT
$cunsafeShiftL :: VkPipelineDiscardRectangleStateCreateFlagsEXT
-> Int -> VkPipelineDiscardRectangleStateCreateFlagsEXT
shiftL :: VkPipelineDiscardRectangleStateCreateFlagsEXT
-> Int -> VkPipelineDiscardRectangleStateCreateFlagsEXT
$cshiftL :: VkPipelineDiscardRectangleStateCreateFlagsEXT
-> Int -> VkPipelineDiscardRectangleStateCreateFlagsEXT
isSigned :: VkPipelineDiscardRectangleStateCreateFlagsEXT -> Bool
$cisSigned :: VkPipelineDiscardRectangleStateCreateFlagsEXT -> Bool
bitSize :: VkPipelineDiscardRectangleStateCreateFlagsEXT -> Int
$cbitSize :: VkPipelineDiscardRectangleStateCreateFlagsEXT -> Int
bitSizeMaybe :: VkPipelineDiscardRectangleStateCreateFlagsEXT -> Maybe Int
$cbitSizeMaybe :: VkPipelineDiscardRectangleStateCreateFlagsEXT -> Maybe Int
testBit :: VkPipelineDiscardRectangleStateCreateFlagsEXT -> Int -> Bool
$ctestBit :: VkPipelineDiscardRectangleStateCreateFlagsEXT -> Int -> Bool
complementBit :: VkPipelineDiscardRectangleStateCreateFlagsEXT
-> Int -> VkPipelineDiscardRectangleStateCreateFlagsEXT
$ccomplementBit :: VkPipelineDiscardRectangleStateCreateFlagsEXT
-> Int -> VkPipelineDiscardRectangleStateCreateFlagsEXT
clearBit :: VkPipelineDiscardRectangleStateCreateFlagsEXT
-> Int -> VkPipelineDiscardRectangleStateCreateFlagsEXT
$cclearBit :: VkPipelineDiscardRectangleStateCreateFlagsEXT
-> Int -> VkPipelineDiscardRectangleStateCreateFlagsEXT
setBit :: VkPipelineDiscardRectangleStateCreateFlagsEXT
-> Int -> VkPipelineDiscardRectangleStateCreateFlagsEXT
$csetBit :: VkPipelineDiscardRectangleStateCreateFlagsEXT
-> Int -> VkPipelineDiscardRectangleStateCreateFlagsEXT
bit :: Int -> VkPipelineDiscardRectangleStateCreateFlagsEXT
$cbit :: Int -> VkPipelineDiscardRectangleStateCreateFlagsEXT
zeroBits :: VkPipelineDiscardRectangleStateCreateFlagsEXT
$czeroBits :: VkPipelineDiscardRectangleStateCreateFlagsEXT
rotate :: VkPipelineDiscardRectangleStateCreateFlagsEXT
-> Int -> VkPipelineDiscardRectangleStateCreateFlagsEXT
$crotate :: VkPipelineDiscardRectangleStateCreateFlagsEXT
-> Int -> VkPipelineDiscardRectangleStateCreateFlagsEXT
shift :: VkPipelineDiscardRectangleStateCreateFlagsEXT
-> Int -> VkPipelineDiscardRectangleStateCreateFlagsEXT
$cshift :: VkPipelineDiscardRectangleStateCreateFlagsEXT
-> Int -> VkPipelineDiscardRectangleStateCreateFlagsEXT
complement :: VkPipelineDiscardRectangleStateCreateFlagsEXT
-> VkPipelineDiscardRectangleStateCreateFlagsEXT
$ccomplement :: VkPipelineDiscardRectangleStateCreateFlagsEXT
-> VkPipelineDiscardRectangleStateCreateFlagsEXT
xor :: VkPipelineDiscardRectangleStateCreateFlagsEXT
-> VkPipelineDiscardRectangleStateCreateFlagsEXT
-> VkPipelineDiscardRectangleStateCreateFlagsEXT
$cxor :: VkPipelineDiscardRectangleStateCreateFlagsEXT
-> VkPipelineDiscardRectangleStateCreateFlagsEXT
-> VkPipelineDiscardRectangleStateCreateFlagsEXT
.|. :: VkPipelineDiscardRectangleStateCreateFlagsEXT
-> VkPipelineDiscardRectangleStateCreateFlagsEXT
-> VkPipelineDiscardRectangleStateCreateFlagsEXT
$c.|. :: VkPipelineDiscardRectangleStateCreateFlagsEXT
-> VkPipelineDiscardRectangleStateCreateFlagsEXT
-> VkPipelineDiscardRectangleStateCreateFlagsEXT
.&. :: VkPipelineDiscardRectangleStateCreateFlagsEXT
-> VkPipelineDiscardRectangleStateCreateFlagsEXT
-> VkPipelineDiscardRectangleStateCreateFlagsEXT
$c.&. :: VkPipelineDiscardRectangleStateCreateFlagsEXT
-> VkPipelineDiscardRectangleStateCreateFlagsEXT
-> VkPipelineDiscardRectangleStateCreateFlagsEXT
Bits, Bits VkPipelineDiscardRectangleStateCreateFlagsEXT
Bits VkPipelineDiscardRectangleStateCreateFlagsEXT
-> (VkPipelineDiscardRectangleStateCreateFlagsEXT -> Int)
-> (VkPipelineDiscardRectangleStateCreateFlagsEXT -> Int)
-> (VkPipelineDiscardRectangleStateCreateFlagsEXT -> Int)
-> FiniteBits VkPipelineDiscardRectangleStateCreateFlagsEXT
VkPipelineDiscardRectangleStateCreateFlagsEXT -> Int
forall b.
Bits b -> (b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
countTrailingZeros :: VkPipelineDiscardRectangleStateCreateFlagsEXT -> Int
$ccountTrailingZeros :: VkPipelineDiscardRectangleStateCreateFlagsEXT -> Int
countLeadingZeros :: VkPipelineDiscardRectangleStateCreateFlagsEXT -> Int
$ccountLeadingZeros :: VkPipelineDiscardRectangleStateCreateFlagsEXT -> Int
finiteBitSize :: VkPipelineDiscardRectangleStateCreateFlagsEXT -> Int
$cfiniteBitSize :: VkPipelineDiscardRectangleStateCreateFlagsEXT -> Int
FiniteBits,
                                                                  Ptr VkPipelineDiscardRectangleStateCreateFlagsEXT
-> IO VkPipelineDiscardRectangleStateCreateFlagsEXT
Ptr VkPipelineDiscardRectangleStateCreateFlagsEXT
-> Int -> IO VkPipelineDiscardRectangleStateCreateFlagsEXT
Ptr VkPipelineDiscardRectangleStateCreateFlagsEXT
-> Int -> VkPipelineDiscardRectangleStateCreateFlagsEXT -> IO ()
Ptr VkPipelineDiscardRectangleStateCreateFlagsEXT
-> VkPipelineDiscardRectangleStateCreateFlagsEXT -> IO ()
VkPipelineDiscardRectangleStateCreateFlagsEXT -> Int
(VkPipelineDiscardRectangleStateCreateFlagsEXT -> Int)
-> (VkPipelineDiscardRectangleStateCreateFlagsEXT -> Int)
-> (Ptr VkPipelineDiscardRectangleStateCreateFlagsEXT
    -> Int -> IO VkPipelineDiscardRectangleStateCreateFlagsEXT)
-> (Ptr VkPipelineDiscardRectangleStateCreateFlagsEXT
    -> Int -> VkPipelineDiscardRectangleStateCreateFlagsEXT -> IO ())
-> (forall b.
    Ptr b -> Int -> IO VkPipelineDiscardRectangleStateCreateFlagsEXT)
-> (forall b.
    Ptr b
    -> Int -> VkPipelineDiscardRectangleStateCreateFlagsEXT -> IO ())
-> (Ptr VkPipelineDiscardRectangleStateCreateFlagsEXT
    -> IO VkPipelineDiscardRectangleStateCreateFlagsEXT)
-> (Ptr VkPipelineDiscardRectangleStateCreateFlagsEXT
    -> VkPipelineDiscardRectangleStateCreateFlagsEXT -> IO ())
-> Storable VkPipelineDiscardRectangleStateCreateFlagsEXT
forall b.
Ptr b -> Int -> IO VkPipelineDiscardRectangleStateCreateFlagsEXT
forall b.
Ptr b
-> Int -> VkPipelineDiscardRectangleStateCreateFlagsEXT -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr VkPipelineDiscardRectangleStateCreateFlagsEXT
-> VkPipelineDiscardRectangleStateCreateFlagsEXT -> IO ()
$cpoke :: Ptr VkPipelineDiscardRectangleStateCreateFlagsEXT
-> VkPipelineDiscardRectangleStateCreateFlagsEXT -> IO ()
peek :: Ptr VkPipelineDiscardRectangleStateCreateFlagsEXT
-> IO VkPipelineDiscardRectangleStateCreateFlagsEXT
$cpeek :: Ptr VkPipelineDiscardRectangleStateCreateFlagsEXT
-> IO VkPipelineDiscardRectangleStateCreateFlagsEXT
pokeByteOff :: forall b.
Ptr b
-> Int -> VkPipelineDiscardRectangleStateCreateFlagsEXT -> IO ()
$cpokeByteOff :: forall b.
Ptr b
-> Int -> VkPipelineDiscardRectangleStateCreateFlagsEXT -> IO ()
peekByteOff :: forall b.
Ptr b -> Int -> IO VkPipelineDiscardRectangleStateCreateFlagsEXT
$cpeekByteOff :: forall b.
Ptr b -> Int -> IO VkPipelineDiscardRectangleStateCreateFlagsEXT
pokeElemOff :: Ptr VkPipelineDiscardRectangleStateCreateFlagsEXT
-> Int -> VkPipelineDiscardRectangleStateCreateFlagsEXT -> IO ()
$cpokeElemOff :: Ptr VkPipelineDiscardRectangleStateCreateFlagsEXT
-> Int -> VkPipelineDiscardRectangleStateCreateFlagsEXT -> IO ()
peekElemOff :: Ptr VkPipelineDiscardRectangleStateCreateFlagsEXT
-> Int -> IO VkPipelineDiscardRectangleStateCreateFlagsEXT
$cpeekElemOff :: Ptr VkPipelineDiscardRectangleStateCreateFlagsEXT
-> Int -> IO VkPipelineDiscardRectangleStateCreateFlagsEXT
alignment :: VkPipelineDiscardRectangleStateCreateFlagsEXT -> Int
$calignment :: VkPipelineDiscardRectangleStateCreateFlagsEXT -> Int
sizeOf :: VkPipelineDiscardRectangleStateCreateFlagsEXT -> Int
$csizeOf :: VkPipelineDiscardRectangleStateCreateFlagsEXT -> Int
Storable)

instance Show VkPipelineDiscardRectangleStateCreateFlagsEXT where
    {-# INLINE showsPrec #-}
    showsPrec :: Int -> VkPipelineDiscardRectangleStateCreateFlagsEXT -> ShowS
showsPrec = (Int -> VkFlags -> ShowS)
-> Int -> VkPipelineDiscardRectangleStateCreateFlagsEXT -> ShowS
coerce (Int -> VkFlags -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec :: Int -> VkFlags -> ShowS)

instance Read VkPipelineDiscardRectangleStateCreateFlagsEXT where
    {-# INLINE readsPrec #-}
    readsPrec :: Int -> ReadS VkPipelineDiscardRectangleStateCreateFlagsEXT
readsPrec = (Int -> ReadS VkFlags)
-> Int -> ReadS VkPipelineDiscardRectangleStateCreateFlagsEXT
coerce (Int -> ReadS VkFlags
forall a. Read a => Int -> ReadS a
readsPrec :: Int -> ReadS VkFlags)

newtype VkPipelineDynamicStateCreateFlags = VkPipelineDynamicStateCreateFlags VkFlags
                                            deriving (VkPipelineDynamicStateCreateFlags
-> VkPipelineDynamicStateCreateFlags -> Bool
(VkPipelineDynamicStateCreateFlags
 -> VkPipelineDynamicStateCreateFlags -> Bool)
-> (VkPipelineDynamicStateCreateFlags
    -> VkPipelineDynamicStateCreateFlags -> Bool)
-> Eq VkPipelineDynamicStateCreateFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VkPipelineDynamicStateCreateFlags
-> VkPipelineDynamicStateCreateFlags -> Bool
$c/= :: VkPipelineDynamicStateCreateFlags
-> VkPipelineDynamicStateCreateFlags -> Bool
== :: VkPipelineDynamicStateCreateFlags
-> VkPipelineDynamicStateCreateFlags -> Bool
$c== :: VkPipelineDynamicStateCreateFlags
-> VkPipelineDynamicStateCreateFlags -> Bool
Eq, Eq VkPipelineDynamicStateCreateFlags
Eq VkPipelineDynamicStateCreateFlags
-> (VkPipelineDynamicStateCreateFlags
    -> VkPipelineDynamicStateCreateFlags -> Ordering)
-> (VkPipelineDynamicStateCreateFlags
    -> VkPipelineDynamicStateCreateFlags -> Bool)
-> (VkPipelineDynamicStateCreateFlags
    -> VkPipelineDynamicStateCreateFlags -> Bool)
-> (VkPipelineDynamicStateCreateFlags
    -> VkPipelineDynamicStateCreateFlags -> Bool)
-> (VkPipelineDynamicStateCreateFlags
    -> VkPipelineDynamicStateCreateFlags -> Bool)
-> (VkPipelineDynamicStateCreateFlags
    -> VkPipelineDynamicStateCreateFlags
    -> VkPipelineDynamicStateCreateFlags)
-> (VkPipelineDynamicStateCreateFlags
    -> VkPipelineDynamicStateCreateFlags
    -> VkPipelineDynamicStateCreateFlags)
-> Ord VkPipelineDynamicStateCreateFlags
VkPipelineDynamicStateCreateFlags
-> VkPipelineDynamicStateCreateFlags -> Bool
VkPipelineDynamicStateCreateFlags
-> VkPipelineDynamicStateCreateFlags -> Ordering
VkPipelineDynamicStateCreateFlags
-> VkPipelineDynamicStateCreateFlags
-> VkPipelineDynamicStateCreateFlags
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: VkPipelineDynamicStateCreateFlags
-> VkPipelineDynamicStateCreateFlags
-> VkPipelineDynamicStateCreateFlags
$cmin :: VkPipelineDynamicStateCreateFlags
-> VkPipelineDynamicStateCreateFlags
-> VkPipelineDynamicStateCreateFlags
max :: VkPipelineDynamicStateCreateFlags
-> VkPipelineDynamicStateCreateFlags
-> VkPipelineDynamicStateCreateFlags
$cmax :: VkPipelineDynamicStateCreateFlags
-> VkPipelineDynamicStateCreateFlags
-> VkPipelineDynamicStateCreateFlags
>= :: VkPipelineDynamicStateCreateFlags
-> VkPipelineDynamicStateCreateFlags -> Bool
$c>= :: VkPipelineDynamicStateCreateFlags
-> VkPipelineDynamicStateCreateFlags -> Bool
> :: VkPipelineDynamicStateCreateFlags
-> VkPipelineDynamicStateCreateFlags -> Bool
$c> :: VkPipelineDynamicStateCreateFlags
-> VkPipelineDynamicStateCreateFlags -> Bool
<= :: VkPipelineDynamicStateCreateFlags
-> VkPipelineDynamicStateCreateFlags -> Bool
$c<= :: VkPipelineDynamicStateCreateFlags
-> VkPipelineDynamicStateCreateFlags -> Bool
< :: VkPipelineDynamicStateCreateFlags
-> VkPipelineDynamicStateCreateFlags -> Bool
$c< :: VkPipelineDynamicStateCreateFlags
-> VkPipelineDynamicStateCreateFlags -> Bool
compare :: VkPipelineDynamicStateCreateFlags
-> VkPipelineDynamicStateCreateFlags -> Ordering
$ccompare :: VkPipelineDynamicStateCreateFlags
-> VkPipelineDynamicStateCreateFlags -> Ordering
Ord, Int -> VkPipelineDynamicStateCreateFlags
VkPipelineDynamicStateCreateFlags -> Int
VkPipelineDynamicStateCreateFlags
-> [VkPipelineDynamicStateCreateFlags]
VkPipelineDynamicStateCreateFlags
-> VkPipelineDynamicStateCreateFlags
VkPipelineDynamicStateCreateFlags
-> VkPipelineDynamicStateCreateFlags
-> [VkPipelineDynamicStateCreateFlags]
VkPipelineDynamicStateCreateFlags
-> VkPipelineDynamicStateCreateFlags
-> VkPipelineDynamicStateCreateFlags
-> [VkPipelineDynamicStateCreateFlags]
(VkPipelineDynamicStateCreateFlags
 -> VkPipelineDynamicStateCreateFlags)
-> (VkPipelineDynamicStateCreateFlags
    -> VkPipelineDynamicStateCreateFlags)
-> (Int -> VkPipelineDynamicStateCreateFlags)
-> (VkPipelineDynamicStateCreateFlags -> Int)
-> (VkPipelineDynamicStateCreateFlags
    -> [VkPipelineDynamicStateCreateFlags])
-> (VkPipelineDynamicStateCreateFlags
    -> VkPipelineDynamicStateCreateFlags
    -> [VkPipelineDynamicStateCreateFlags])
-> (VkPipelineDynamicStateCreateFlags
    -> VkPipelineDynamicStateCreateFlags
    -> [VkPipelineDynamicStateCreateFlags])
-> (VkPipelineDynamicStateCreateFlags
    -> VkPipelineDynamicStateCreateFlags
    -> VkPipelineDynamicStateCreateFlags
    -> [VkPipelineDynamicStateCreateFlags])
-> Enum VkPipelineDynamicStateCreateFlags
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: VkPipelineDynamicStateCreateFlags
-> VkPipelineDynamicStateCreateFlags
-> VkPipelineDynamicStateCreateFlags
-> [VkPipelineDynamicStateCreateFlags]
$cenumFromThenTo :: VkPipelineDynamicStateCreateFlags
-> VkPipelineDynamicStateCreateFlags
-> VkPipelineDynamicStateCreateFlags
-> [VkPipelineDynamicStateCreateFlags]
enumFromTo :: VkPipelineDynamicStateCreateFlags
-> VkPipelineDynamicStateCreateFlags
-> [VkPipelineDynamicStateCreateFlags]
$cenumFromTo :: VkPipelineDynamicStateCreateFlags
-> VkPipelineDynamicStateCreateFlags
-> [VkPipelineDynamicStateCreateFlags]
enumFromThen :: VkPipelineDynamicStateCreateFlags
-> VkPipelineDynamicStateCreateFlags
-> [VkPipelineDynamicStateCreateFlags]
$cenumFromThen :: VkPipelineDynamicStateCreateFlags
-> VkPipelineDynamicStateCreateFlags
-> [VkPipelineDynamicStateCreateFlags]
enumFrom :: VkPipelineDynamicStateCreateFlags
-> [VkPipelineDynamicStateCreateFlags]
$cenumFrom :: VkPipelineDynamicStateCreateFlags
-> [VkPipelineDynamicStateCreateFlags]
fromEnum :: VkPipelineDynamicStateCreateFlags -> Int
$cfromEnum :: VkPipelineDynamicStateCreateFlags -> Int
toEnum :: Int -> VkPipelineDynamicStateCreateFlags
$ctoEnum :: Int -> VkPipelineDynamicStateCreateFlags
pred :: VkPipelineDynamicStateCreateFlags
-> VkPipelineDynamicStateCreateFlags
$cpred :: VkPipelineDynamicStateCreateFlags
-> VkPipelineDynamicStateCreateFlags
succ :: VkPipelineDynamicStateCreateFlags
-> VkPipelineDynamicStateCreateFlags
$csucc :: VkPipelineDynamicStateCreateFlags
-> VkPipelineDynamicStateCreateFlags
Enum, Eq VkPipelineDynamicStateCreateFlags
VkPipelineDynamicStateCreateFlags
Eq VkPipelineDynamicStateCreateFlags
-> (VkPipelineDynamicStateCreateFlags
    -> VkPipelineDynamicStateCreateFlags
    -> VkPipelineDynamicStateCreateFlags)
-> (VkPipelineDynamicStateCreateFlags
    -> VkPipelineDynamicStateCreateFlags
    -> VkPipelineDynamicStateCreateFlags)
-> (VkPipelineDynamicStateCreateFlags
    -> VkPipelineDynamicStateCreateFlags
    -> VkPipelineDynamicStateCreateFlags)
-> (VkPipelineDynamicStateCreateFlags
    -> VkPipelineDynamicStateCreateFlags)
-> (VkPipelineDynamicStateCreateFlags
    -> Int -> VkPipelineDynamicStateCreateFlags)
-> (VkPipelineDynamicStateCreateFlags
    -> Int -> VkPipelineDynamicStateCreateFlags)
-> VkPipelineDynamicStateCreateFlags
-> (Int -> VkPipelineDynamicStateCreateFlags)
-> (VkPipelineDynamicStateCreateFlags
    -> Int -> VkPipelineDynamicStateCreateFlags)
-> (VkPipelineDynamicStateCreateFlags
    -> Int -> VkPipelineDynamicStateCreateFlags)
-> (VkPipelineDynamicStateCreateFlags
    -> Int -> VkPipelineDynamicStateCreateFlags)
-> (VkPipelineDynamicStateCreateFlags -> Int -> Bool)
-> (VkPipelineDynamicStateCreateFlags -> Maybe Int)
-> (VkPipelineDynamicStateCreateFlags -> Int)
-> (VkPipelineDynamicStateCreateFlags -> Bool)
-> (VkPipelineDynamicStateCreateFlags
    -> Int -> VkPipelineDynamicStateCreateFlags)
-> (VkPipelineDynamicStateCreateFlags
    -> Int -> VkPipelineDynamicStateCreateFlags)
-> (VkPipelineDynamicStateCreateFlags
    -> Int -> VkPipelineDynamicStateCreateFlags)
-> (VkPipelineDynamicStateCreateFlags
    -> Int -> VkPipelineDynamicStateCreateFlags)
-> (VkPipelineDynamicStateCreateFlags
    -> Int -> VkPipelineDynamicStateCreateFlags)
-> (VkPipelineDynamicStateCreateFlags
    -> Int -> VkPipelineDynamicStateCreateFlags)
-> (VkPipelineDynamicStateCreateFlags -> Int)
-> Bits VkPipelineDynamicStateCreateFlags
Int -> VkPipelineDynamicStateCreateFlags
VkPipelineDynamicStateCreateFlags -> Bool
VkPipelineDynamicStateCreateFlags -> Int
VkPipelineDynamicStateCreateFlags -> Maybe Int
VkPipelineDynamicStateCreateFlags
-> VkPipelineDynamicStateCreateFlags
VkPipelineDynamicStateCreateFlags -> Int -> Bool
VkPipelineDynamicStateCreateFlags
-> Int -> VkPipelineDynamicStateCreateFlags
VkPipelineDynamicStateCreateFlags
-> VkPipelineDynamicStateCreateFlags
-> VkPipelineDynamicStateCreateFlags
forall a.
Eq a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
popCount :: VkPipelineDynamicStateCreateFlags -> Int
$cpopCount :: VkPipelineDynamicStateCreateFlags -> Int
rotateR :: VkPipelineDynamicStateCreateFlags
-> Int -> VkPipelineDynamicStateCreateFlags
$crotateR :: VkPipelineDynamicStateCreateFlags
-> Int -> VkPipelineDynamicStateCreateFlags
rotateL :: VkPipelineDynamicStateCreateFlags
-> Int -> VkPipelineDynamicStateCreateFlags
$crotateL :: VkPipelineDynamicStateCreateFlags
-> Int -> VkPipelineDynamicStateCreateFlags
unsafeShiftR :: VkPipelineDynamicStateCreateFlags
-> Int -> VkPipelineDynamicStateCreateFlags
$cunsafeShiftR :: VkPipelineDynamicStateCreateFlags
-> Int -> VkPipelineDynamicStateCreateFlags
shiftR :: VkPipelineDynamicStateCreateFlags
-> Int -> VkPipelineDynamicStateCreateFlags
$cshiftR :: VkPipelineDynamicStateCreateFlags
-> Int -> VkPipelineDynamicStateCreateFlags
unsafeShiftL :: VkPipelineDynamicStateCreateFlags
-> Int -> VkPipelineDynamicStateCreateFlags
$cunsafeShiftL :: VkPipelineDynamicStateCreateFlags
-> Int -> VkPipelineDynamicStateCreateFlags
shiftL :: VkPipelineDynamicStateCreateFlags
-> Int -> VkPipelineDynamicStateCreateFlags
$cshiftL :: VkPipelineDynamicStateCreateFlags
-> Int -> VkPipelineDynamicStateCreateFlags
isSigned :: VkPipelineDynamicStateCreateFlags -> Bool
$cisSigned :: VkPipelineDynamicStateCreateFlags -> Bool
bitSize :: VkPipelineDynamicStateCreateFlags -> Int
$cbitSize :: VkPipelineDynamicStateCreateFlags -> Int
bitSizeMaybe :: VkPipelineDynamicStateCreateFlags -> Maybe Int
$cbitSizeMaybe :: VkPipelineDynamicStateCreateFlags -> Maybe Int
testBit :: VkPipelineDynamicStateCreateFlags -> Int -> Bool
$ctestBit :: VkPipelineDynamicStateCreateFlags -> Int -> Bool
complementBit :: VkPipelineDynamicStateCreateFlags
-> Int -> VkPipelineDynamicStateCreateFlags
$ccomplementBit :: VkPipelineDynamicStateCreateFlags
-> Int -> VkPipelineDynamicStateCreateFlags
clearBit :: VkPipelineDynamicStateCreateFlags
-> Int -> VkPipelineDynamicStateCreateFlags
$cclearBit :: VkPipelineDynamicStateCreateFlags
-> Int -> VkPipelineDynamicStateCreateFlags
setBit :: VkPipelineDynamicStateCreateFlags
-> Int -> VkPipelineDynamicStateCreateFlags
$csetBit :: VkPipelineDynamicStateCreateFlags
-> Int -> VkPipelineDynamicStateCreateFlags
bit :: Int -> VkPipelineDynamicStateCreateFlags
$cbit :: Int -> VkPipelineDynamicStateCreateFlags
zeroBits :: VkPipelineDynamicStateCreateFlags
$czeroBits :: VkPipelineDynamicStateCreateFlags
rotate :: VkPipelineDynamicStateCreateFlags
-> Int -> VkPipelineDynamicStateCreateFlags
$crotate :: VkPipelineDynamicStateCreateFlags
-> Int -> VkPipelineDynamicStateCreateFlags
shift :: VkPipelineDynamicStateCreateFlags
-> Int -> VkPipelineDynamicStateCreateFlags
$cshift :: VkPipelineDynamicStateCreateFlags
-> Int -> VkPipelineDynamicStateCreateFlags
complement :: VkPipelineDynamicStateCreateFlags
-> VkPipelineDynamicStateCreateFlags
$ccomplement :: VkPipelineDynamicStateCreateFlags
-> VkPipelineDynamicStateCreateFlags
xor :: VkPipelineDynamicStateCreateFlags
-> VkPipelineDynamicStateCreateFlags
-> VkPipelineDynamicStateCreateFlags
$cxor :: VkPipelineDynamicStateCreateFlags
-> VkPipelineDynamicStateCreateFlags
-> VkPipelineDynamicStateCreateFlags
.|. :: VkPipelineDynamicStateCreateFlags
-> VkPipelineDynamicStateCreateFlags
-> VkPipelineDynamicStateCreateFlags
$c.|. :: VkPipelineDynamicStateCreateFlags
-> VkPipelineDynamicStateCreateFlags
-> VkPipelineDynamicStateCreateFlags
.&. :: VkPipelineDynamicStateCreateFlags
-> VkPipelineDynamicStateCreateFlags
-> VkPipelineDynamicStateCreateFlags
$c.&. :: VkPipelineDynamicStateCreateFlags
-> VkPipelineDynamicStateCreateFlags
-> VkPipelineDynamicStateCreateFlags
Bits, Bits VkPipelineDynamicStateCreateFlags
Bits VkPipelineDynamicStateCreateFlags
-> (VkPipelineDynamicStateCreateFlags -> Int)
-> (VkPipelineDynamicStateCreateFlags -> Int)
-> (VkPipelineDynamicStateCreateFlags -> Int)
-> FiniteBits VkPipelineDynamicStateCreateFlags
VkPipelineDynamicStateCreateFlags -> Int
forall b.
Bits b -> (b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
countTrailingZeros :: VkPipelineDynamicStateCreateFlags -> Int
$ccountTrailingZeros :: VkPipelineDynamicStateCreateFlags -> Int
countLeadingZeros :: VkPipelineDynamicStateCreateFlags -> Int
$ccountLeadingZeros :: VkPipelineDynamicStateCreateFlags -> Int
finiteBitSize :: VkPipelineDynamicStateCreateFlags -> Int
$cfiniteBitSize :: VkPipelineDynamicStateCreateFlags -> Int
FiniteBits, Ptr VkPipelineDynamicStateCreateFlags
-> IO VkPipelineDynamicStateCreateFlags
Ptr VkPipelineDynamicStateCreateFlags
-> Int -> IO VkPipelineDynamicStateCreateFlags
Ptr VkPipelineDynamicStateCreateFlags
-> Int -> VkPipelineDynamicStateCreateFlags -> IO ()
Ptr VkPipelineDynamicStateCreateFlags
-> VkPipelineDynamicStateCreateFlags -> IO ()
VkPipelineDynamicStateCreateFlags -> Int
(VkPipelineDynamicStateCreateFlags -> Int)
-> (VkPipelineDynamicStateCreateFlags -> Int)
-> (Ptr VkPipelineDynamicStateCreateFlags
    -> Int -> IO VkPipelineDynamicStateCreateFlags)
-> (Ptr VkPipelineDynamicStateCreateFlags
    -> Int -> VkPipelineDynamicStateCreateFlags -> IO ())
-> (forall b. Ptr b -> Int -> IO VkPipelineDynamicStateCreateFlags)
-> (forall b.
    Ptr b -> Int -> VkPipelineDynamicStateCreateFlags -> IO ())
-> (Ptr VkPipelineDynamicStateCreateFlags
    -> IO VkPipelineDynamicStateCreateFlags)
-> (Ptr VkPipelineDynamicStateCreateFlags
    -> VkPipelineDynamicStateCreateFlags -> IO ())
-> Storable VkPipelineDynamicStateCreateFlags
forall b. Ptr b -> Int -> IO VkPipelineDynamicStateCreateFlags
forall b.
Ptr b -> Int -> VkPipelineDynamicStateCreateFlags -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr VkPipelineDynamicStateCreateFlags
-> VkPipelineDynamicStateCreateFlags -> IO ()
$cpoke :: Ptr VkPipelineDynamicStateCreateFlags
-> VkPipelineDynamicStateCreateFlags -> IO ()
peek :: Ptr VkPipelineDynamicStateCreateFlags
-> IO VkPipelineDynamicStateCreateFlags
$cpeek :: Ptr VkPipelineDynamicStateCreateFlags
-> IO VkPipelineDynamicStateCreateFlags
pokeByteOff :: forall b.
Ptr b -> Int -> VkPipelineDynamicStateCreateFlags -> IO ()
$cpokeByteOff :: forall b.
Ptr b -> Int -> VkPipelineDynamicStateCreateFlags -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO VkPipelineDynamicStateCreateFlags
$cpeekByteOff :: forall b. Ptr b -> Int -> IO VkPipelineDynamicStateCreateFlags
pokeElemOff :: Ptr VkPipelineDynamicStateCreateFlags
-> Int -> VkPipelineDynamicStateCreateFlags -> IO ()
$cpokeElemOff :: Ptr VkPipelineDynamicStateCreateFlags
-> Int -> VkPipelineDynamicStateCreateFlags -> IO ()
peekElemOff :: Ptr VkPipelineDynamicStateCreateFlags
-> Int -> IO VkPipelineDynamicStateCreateFlags
$cpeekElemOff :: Ptr VkPipelineDynamicStateCreateFlags
-> Int -> IO VkPipelineDynamicStateCreateFlags
alignment :: VkPipelineDynamicStateCreateFlags -> Int
$calignment :: VkPipelineDynamicStateCreateFlags -> Int
sizeOf :: VkPipelineDynamicStateCreateFlags -> Int
$csizeOf :: VkPipelineDynamicStateCreateFlags -> Int
Storable)

instance Show VkPipelineDynamicStateCreateFlags where
    {-# INLINE showsPrec #-}
    showsPrec :: Int -> VkPipelineDynamicStateCreateFlags -> ShowS
showsPrec = (Int -> VkFlags -> ShowS)
-> Int -> VkPipelineDynamicStateCreateFlags -> ShowS
coerce (Int -> VkFlags -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec :: Int -> VkFlags -> ShowS)

instance Read VkPipelineDynamicStateCreateFlags where
    {-# INLINE readsPrec #-}
    readsPrec :: Int -> ReadS VkPipelineDynamicStateCreateFlags
readsPrec = (Int -> ReadS VkFlags)
-> Int -> ReadS VkPipelineDynamicStateCreateFlags
coerce (Int -> ReadS VkFlags
forall a. Read a => Int -> ReadS a
readsPrec :: Int -> ReadS VkFlags)

newtype VkPipelineInputAssemblyStateCreateFlags = VkPipelineInputAssemblyStateCreateFlags VkFlags
                                                  deriving (VkPipelineInputAssemblyStateCreateFlags
-> VkPipelineInputAssemblyStateCreateFlags -> Bool
(VkPipelineInputAssemblyStateCreateFlags
 -> VkPipelineInputAssemblyStateCreateFlags -> Bool)
-> (VkPipelineInputAssemblyStateCreateFlags
    -> VkPipelineInputAssemblyStateCreateFlags -> Bool)
-> Eq VkPipelineInputAssemblyStateCreateFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VkPipelineInputAssemblyStateCreateFlags
-> VkPipelineInputAssemblyStateCreateFlags -> Bool
$c/= :: VkPipelineInputAssemblyStateCreateFlags
-> VkPipelineInputAssemblyStateCreateFlags -> Bool
== :: VkPipelineInputAssemblyStateCreateFlags
-> VkPipelineInputAssemblyStateCreateFlags -> Bool
$c== :: VkPipelineInputAssemblyStateCreateFlags
-> VkPipelineInputAssemblyStateCreateFlags -> Bool
Eq, Eq VkPipelineInputAssemblyStateCreateFlags
Eq VkPipelineInputAssemblyStateCreateFlags
-> (VkPipelineInputAssemblyStateCreateFlags
    -> VkPipelineInputAssemblyStateCreateFlags -> Ordering)
-> (VkPipelineInputAssemblyStateCreateFlags
    -> VkPipelineInputAssemblyStateCreateFlags -> Bool)
-> (VkPipelineInputAssemblyStateCreateFlags
    -> VkPipelineInputAssemblyStateCreateFlags -> Bool)
-> (VkPipelineInputAssemblyStateCreateFlags
    -> VkPipelineInputAssemblyStateCreateFlags -> Bool)
-> (VkPipelineInputAssemblyStateCreateFlags
    -> VkPipelineInputAssemblyStateCreateFlags -> Bool)
-> (VkPipelineInputAssemblyStateCreateFlags
    -> VkPipelineInputAssemblyStateCreateFlags
    -> VkPipelineInputAssemblyStateCreateFlags)
-> (VkPipelineInputAssemblyStateCreateFlags
    -> VkPipelineInputAssemblyStateCreateFlags
    -> VkPipelineInputAssemblyStateCreateFlags)
-> Ord VkPipelineInputAssemblyStateCreateFlags
VkPipelineInputAssemblyStateCreateFlags
-> VkPipelineInputAssemblyStateCreateFlags -> Bool
VkPipelineInputAssemblyStateCreateFlags
-> VkPipelineInputAssemblyStateCreateFlags -> Ordering
VkPipelineInputAssemblyStateCreateFlags
-> VkPipelineInputAssemblyStateCreateFlags
-> VkPipelineInputAssemblyStateCreateFlags
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: VkPipelineInputAssemblyStateCreateFlags
-> VkPipelineInputAssemblyStateCreateFlags
-> VkPipelineInputAssemblyStateCreateFlags
$cmin :: VkPipelineInputAssemblyStateCreateFlags
-> VkPipelineInputAssemblyStateCreateFlags
-> VkPipelineInputAssemblyStateCreateFlags
max :: VkPipelineInputAssemblyStateCreateFlags
-> VkPipelineInputAssemblyStateCreateFlags
-> VkPipelineInputAssemblyStateCreateFlags
$cmax :: VkPipelineInputAssemblyStateCreateFlags
-> VkPipelineInputAssemblyStateCreateFlags
-> VkPipelineInputAssemblyStateCreateFlags
>= :: VkPipelineInputAssemblyStateCreateFlags
-> VkPipelineInputAssemblyStateCreateFlags -> Bool
$c>= :: VkPipelineInputAssemblyStateCreateFlags
-> VkPipelineInputAssemblyStateCreateFlags -> Bool
> :: VkPipelineInputAssemblyStateCreateFlags
-> VkPipelineInputAssemblyStateCreateFlags -> Bool
$c> :: VkPipelineInputAssemblyStateCreateFlags
-> VkPipelineInputAssemblyStateCreateFlags -> Bool
<= :: VkPipelineInputAssemblyStateCreateFlags
-> VkPipelineInputAssemblyStateCreateFlags -> Bool
$c<= :: VkPipelineInputAssemblyStateCreateFlags
-> VkPipelineInputAssemblyStateCreateFlags -> Bool
< :: VkPipelineInputAssemblyStateCreateFlags
-> VkPipelineInputAssemblyStateCreateFlags -> Bool
$c< :: VkPipelineInputAssemblyStateCreateFlags
-> VkPipelineInputAssemblyStateCreateFlags -> Bool
compare :: VkPipelineInputAssemblyStateCreateFlags
-> VkPipelineInputAssemblyStateCreateFlags -> Ordering
$ccompare :: VkPipelineInputAssemblyStateCreateFlags
-> VkPipelineInputAssemblyStateCreateFlags -> Ordering
Ord, Int -> VkPipelineInputAssemblyStateCreateFlags
VkPipelineInputAssemblyStateCreateFlags -> Int
VkPipelineInputAssemblyStateCreateFlags
-> [VkPipelineInputAssemblyStateCreateFlags]
VkPipelineInputAssemblyStateCreateFlags
-> VkPipelineInputAssemblyStateCreateFlags
VkPipelineInputAssemblyStateCreateFlags
-> VkPipelineInputAssemblyStateCreateFlags
-> [VkPipelineInputAssemblyStateCreateFlags]
VkPipelineInputAssemblyStateCreateFlags
-> VkPipelineInputAssemblyStateCreateFlags
-> VkPipelineInputAssemblyStateCreateFlags
-> [VkPipelineInputAssemblyStateCreateFlags]
(VkPipelineInputAssemblyStateCreateFlags
 -> VkPipelineInputAssemblyStateCreateFlags)
-> (VkPipelineInputAssemblyStateCreateFlags
    -> VkPipelineInputAssemblyStateCreateFlags)
-> (Int -> VkPipelineInputAssemblyStateCreateFlags)
-> (VkPipelineInputAssemblyStateCreateFlags -> Int)
-> (VkPipelineInputAssemblyStateCreateFlags
    -> [VkPipelineInputAssemblyStateCreateFlags])
-> (VkPipelineInputAssemblyStateCreateFlags
    -> VkPipelineInputAssemblyStateCreateFlags
    -> [VkPipelineInputAssemblyStateCreateFlags])
-> (VkPipelineInputAssemblyStateCreateFlags
    -> VkPipelineInputAssemblyStateCreateFlags
    -> [VkPipelineInputAssemblyStateCreateFlags])
-> (VkPipelineInputAssemblyStateCreateFlags
    -> VkPipelineInputAssemblyStateCreateFlags
    -> VkPipelineInputAssemblyStateCreateFlags
    -> [VkPipelineInputAssemblyStateCreateFlags])
-> Enum VkPipelineInputAssemblyStateCreateFlags
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: VkPipelineInputAssemblyStateCreateFlags
-> VkPipelineInputAssemblyStateCreateFlags
-> VkPipelineInputAssemblyStateCreateFlags
-> [VkPipelineInputAssemblyStateCreateFlags]
$cenumFromThenTo :: VkPipelineInputAssemblyStateCreateFlags
-> VkPipelineInputAssemblyStateCreateFlags
-> VkPipelineInputAssemblyStateCreateFlags
-> [VkPipelineInputAssemblyStateCreateFlags]
enumFromTo :: VkPipelineInputAssemblyStateCreateFlags
-> VkPipelineInputAssemblyStateCreateFlags
-> [VkPipelineInputAssemblyStateCreateFlags]
$cenumFromTo :: VkPipelineInputAssemblyStateCreateFlags
-> VkPipelineInputAssemblyStateCreateFlags
-> [VkPipelineInputAssemblyStateCreateFlags]
enumFromThen :: VkPipelineInputAssemblyStateCreateFlags
-> VkPipelineInputAssemblyStateCreateFlags
-> [VkPipelineInputAssemblyStateCreateFlags]
$cenumFromThen :: VkPipelineInputAssemblyStateCreateFlags
-> VkPipelineInputAssemblyStateCreateFlags
-> [VkPipelineInputAssemblyStateCreateFlags]
enumFrom :: VkPipelineInputAssemblyStateCreateFlags
-> [VkPipelineInputAssemblyStateCreateFlags]
$cenumFrom :: VkPipelineInputAssemblyStateCreateFlags
-> [VkPipelineInputAssemblyStateCreateFlags]
fromEnum :: VkPipelineInputAssemblyStateCreateFlags -> Int
$cfromEnum :: VkPipelineInputAssemblyStateCreateFlags -> Int
toEnum :: Int -> VkPipelineInputAssemblyStateCreateFlags
$ctoEnum :: Int -> VkPipelineInputAssemblyStateCreateFlags
pred :: VkPipelineInputAssemblyStateCreateFlags
-> VkPipelineInputAssemblyStateCreateFlags
$cpred :: VkPipelineInputAssemblyStateCreateFlags
-> VkPipelineInputAssemblyStateCreateFlags
succ :: VkPipelineInputAssemblyStateCreateFlags
-> VkPipelineInputAssemblyStateCreateFlags
$csucc :: VkPipelineInputAssemblyStateCreateFlags
-> VkPipelineInputAssemblyStateCreateFlags
Enum, Eq VkPipelineInputAssemblyStateCreateFlags
VkPipelineInputAssemblyStateCreateFlags
Eq VkPipelineInputAssemblyStateCreateFlags
-> (VkPipelineInputAssemblyStateCreateFlags
    -> VkPipelineInputAssemblyStateCreateFlags
    -> VkPipelineInputAssemblyStateCreateFlags)
-> (VkPipelineInputAssemblyStateCreateFlags
    -> VkPipelineInputAssemblyStateCreateFlags
    -> VkPipelineInputAssemblyStateCreateFlags)
-> (VkPipelineInputAssemblyStateCreateFlags
    -> VkPipelineInputAssemblyStateCreateFlags
    -> VkPipelineInputAssemblyStateCreateFlags)
-> (VkPipelineInputAssemblyStateCreateFlags
    -> VkPipelineInputAssemblyStateCreateFlags)
-> (VkPipelineInputAssemblyStateCreateFlags
    -> Int -> VkPipelineInputAssemblyStateCreateFlags)
-> (VkPipelineInputAssemblyStateCreateFlags
    -> Int -> VkPipelineInputAssemblyStateCreateFlags)
-> VkPipelineInputAssemblyStateCreateFlags
-> (Int -> VkPipelineInputAssemblyStateCreateFlags)
-> (VkPipelineInputAssemblyStateCreateFlags
    -> Int -> VkPipelineInputAssemblyStateCreateFlags)
-> (VkPipelineInputAssemblyStateCreateFlags
    -> Int -> VkPipelineInputAssemblyStateCreateFlags)
-> (VkPipelineInputAssemblyStateCreateFlags
    -> Int -> VkPipelineInputAssemblyStateCreateFlags)
-> (VkPipelineInputAssemblyStateCreateFlags -> Int -> Bool)
-> (VkPipelineInputAssemblyStateCreateFlags -> Maybe Int)
-> (VkPipelineInputAssemblyStateCreateFlags -> Int)
-> (VkPipelineInputAssemblyStateCreateFlags -> Bool)
-> (VkPipelineInputAssemblyStateCreateFlags
    -> Int -> VkPipelineInputAssemblyStateCreateFlags)
-> (VkPipelineInputAssemblyStateCreateFlags
    -> Int -> VkPipelineInputAssemblyStateCreateFlags)
-> (VkPipelineInputAssemblyStateCreateFlags
    -> Int -> VkPipelineInputAssemblyStateCreateFlags)
-> (VkPipelineInputAssemblyStateCreateFlags
    -> Int -> VkPipelineInputAssemblyStateCreateFlags)
-> (VkPipelineInputAssemblyStateCreateFlags
    -> Int -> VkPipelineInputAssemblyStateCreateFlags)
-> (VkPipelineInputAssemblyStateCreateFlags
    -> Int -> VkPipelineInputAssemblyStateCreateFlags)
-> (VkPipelineInputAssemblyStateCreateFlags -> Int)
-> Bits VkPipelineInputAssemblyStateCreateFlags
Int -> VkPipelineInputAssemblyStateCreateFlags
VkPipelineInputAssemblyStateCreateFlags -> Bool
VkPipelineInputAssemblyStateCreateFlags -> Int
VkPipelineInputAssemblyStateCreateFlags -> Maybe Int
VkPipelineInputAssemblyStateCreateFlags
-> VkPipelineInputAssemblyStateCreateFlags
VkPipelineInputAssemblyStateCreateFlags -> Int -> Bool
VkPipelineInputAssemblyStateCreateFlags
-> Int -> VkPipelineInputAssemblyStateCreateFlags
VkPipelineInputAssemblyStateCreateFlags
-> VkPipelineInputAssemblyStateCreateFlags
-> VkPipelineInputAssemblyStateCreateFlags
forall a.
Eq a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
popCount :: VkPipelineInputAssemblyStateCreateFlags -> Int
$cpopCount :: VkPipelineInputAssemblyStateCreateFlags -> Int
rotateR :: VkPipelineInputAssemblyStateCreateFlags
-> Int -> VkPipelineInputAssemblyStateCreateFlags
$crotateR :: VkPipelineInputAssemblyStateCreateFlags
-> Int -> VkPipelineInputAssemblyStateCreateFlags
rotateL :: VkPipelineInputAssemblyStateCreateFlags
-> Int -> VkPipelineInputAssemblyStateCreateFlags
$crotateL :: VkPipelineInputAssemblyStateCreateFlags
-> Int -> VkPipelineInputAssemblyStateCreateFlags
unsafeShiftR :: VkPipelineInputAssemblyStateCreateFlags
-> Int -> VkPipelineInputAssemblyStateCreateFlags
$cunsafeShiftR :: VkPipelineInputAssemblyStateCreateFlags
-> Int -> VkPipelineInputAssemblyStateCreateFlags
shiftR :: VkPipelineInputAssemblyStateCreateFlags
-> Int -> VkPipelineInputAssemblyStateCreateFlags
$cshiftR :: VkPipelineInputAssemblyStateCreateFlags
-> Int -> VkPipelineInputAssemblyStateCreateFlags
unsafeShiftL :: VkPipelineInputAssemblyStateCreateFlags
-> Int -> VkPipelineInputAssemblyStateCreateFlags
$cunsafeShiftL :: VkPipelineInputAssemblyStateCreateFlags
-> Int -> VkPipelineInputAssemblyStateCreateFlags
shiftL :: VkPipelineInputAssemblyStateCreateFlags
-> Int -> VkPipelineInputAssemblyStateCreateFlags
$cshiftL :: VkPipelineInputAssemblyStateCreateFlags
-> Int -> VkPipelineInputAssemblyStateCreateFlags
isSigned :: VkPipelineInputAssemblyStateCreateFlags -> Bool
$cisSigned :: VkPipelineInputAssemblyStateCreateFlags -> Bool
bitSize :: VkPipelineInputAssemblyStateCreateFlags -> Int
$cbitSize :: VkPipelineInputAssemblyStateCreateFlags -> Int
bitSizeMaybe :: VkPipelineInputAssemblyStateCreateFlags -> Maybe Int
$cbitSizeMaybe :: VkPipelineInputAssemblyStateCreateFlags -> Maybe Int
testBit :: VkPipelineInputAssemblyStateCreateFlags -> Int -> Bool
$ctestBit :: VkPipelineInputAssemblyStateCreateFlags -> Int -> Bool
complementBit :: VkPipelineInputAssemblyStateCreateFlags
-> Int -> VkPipelineInputAssemblyStateCreateFlags
$ccomplementBit :: VkPipelineInputAssemblyStateCreateFlags
-> Int -> VkPipelineInputAssemblyStateCreateFlags
clearBit :: VkPipelineInputAssemblyStateCreateFlags
-> Int -> VkPipelineInputAssemblyStateCreateFlags
$cclearBit :: VkPipelineInputAssemblyStateCreateFlags
-> Int -> VkPipelineInputAssemblyStateCreateFlags
setBit :: VkPipelineInputAssemblyStateCreateFlags
-> Int -> VkPipelineInputAssemblyStateCreateFlags
$csetBit :: VkPipelineInputAssemblyStateCreateFlags
-> Int -> VkPipelineInputAssemblyStateCreateFlags
bit :: Int -> VkPipelineInputAssemblyStateCreateFlags
$cbit :: Int -> VkPipelineInputAssemblyStateCreateFlags
zeroBits :: VkPipelineInputAssemblyStateCreateFlags
$czeroBits :: VkPipelineInputAssemblyStateCreateFlags
rotate :: VkPipelineInputAssemblyStateCreateFlags
-> Int -> VkPipelineInputAssemblyStateCreateFlags
$crotate :: VkPipelineInputAssemblyStateCreateFlags
-> Int -> VkPipelineInputAssemblyStateCreateFlags
shift :: VkPipelineInputAssemblyStateCreateFlags
-> Int -> VkPipelineInputAssemblyStateCreateFlags
$cshift :: VkPipelineInputAssemblyStateCreateFlags
-> Int -> VkPipelineInputAssemblyStateCreateFlags
complement :: VkPipelineInputAssemblyStateCreateFlags
-> VkPipelineInputAssemblyStateCreateFlags
$ccomplement :: VkPipelineInputAssemblyStateCreateFlags
-> VkPipelineInputAssemblyStateCreateFlags
xor :: VkPipelineInputAssemblyStateCreateFlags
-> VkPipelineInputAssemblyStateCreateFlags
-> VkPipelineInputAssemblyStateCreateFlags
$cxor :: VkPipelineInputAssemblyStateCreateFlags
-> VkPipelineInputAssemblyStateCreateFlags
-> VkPipelineInputAssemblyStateCreateFlags
.|. :: VkPipelineInputAssemblyStateCreateFlags
-> VkPipelineInputAssemblyStateCreateFlags
-> VkPipelineInputAssemblyStateCreateFlags
$c.|. :: VkPipelineInputAssemblyStateCreateFlags
-> VkPipelineInputAssemblyStateCreateFlags
-> VkPipelineInputAssemblyStateCreateFlags
.&. :: VkPipelineInputAssemblyStateCreateFlags
-> VkPipelineInputAssemblyStateCreateFlags
-> VkPipelineInputAssemblyStateCreateFlags
$c.&. :: VkPipelineInputAssemblyStateCreateFlags
-> VkPipelineInputAssemblyStateCreateFlags
-> VkPipelineInputAssemblyStateCreateFlags
Bits, Bits VkPipelineInputAssemblyStateCreateFlags
Bits VkPipelineInputAssemblyStateCreateFlags
-> (VkPipelineInputAssemblyStateCreateFlags -> Int)
-> (VkPipelineInputAssemblyStateCreateFlags -> Int)
-> (VkPipelineInputAssemblyStateCreateFlags -> Int)
-> FiniteBits VkPipelineInputAssemblyStateCreateFlags
VkPipelineInputAssemblyStateCreateFlags -> Int
forall b.
Bits b -> (b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
countTrailingZeros :: VkPipelineInputAssemblyStateCreateFlags -> Int
$ccountTrailingZeros :: VkPipelineInputAssemblyStateCreateFlags -> Int
countLeadingZeros :: VkPipelineInputAssemblyStateCreateFlags -> Int
$ccountLeadingZeros :: VkPipelineInputAssemblyStateCreateFlags -> Int
finiteBitSize :: VkPipelineInputAssemblyStateCreateFlags -> Int
$cfiniteBitSize :: VkPipelineInputAssemblyStateCreateFlags -> Int
FiniteBits,
                                                            Ptr VkPipelineInputAssemblyStateCreateFlags
-> IO VkPipelineInputAssemblyStateCreateFlags
Ptr VkPipelineInputAssemblyStateCreateFlags
-> Int -> IO VkPipelineInputAssemblyStateCreateFlags
Ptr VkPipelineInputAssemblyStateCreateFlags
-> Int -> VkPipelineInputAssemblyStateCreateFlags -> IO ()
Ptr VkPipelineInputAssemblyStateCreateFlags
-> VkPipelineInputAssemblyStateCreateFlags -> IO ()
VkPipelineInputAssemblyStateCreateFlags -> Int
(VkPipelineInputAssemblyStateCreateFlags -> Int)
-> (VkPipelineInputAssemblyStateCreateFlags -> Int)
-> (Ptr VkPipelineInputAssemblyStateCreateFlags
    -> Int -> IO VkPipelineInputAssemblyStateCreateFlags)
-> (Ptr VkPipelineInputAssemblyStateCreateFlags
    -> Int -> VkPipelineInputAssemblyStateCreateFlags -> IO ())
-> (forall b.
    Ptr b -> Int -> IO VkPipelineInputAssemblyStateCreateFlags)
-> (forall b.
    Ptr b -> Int -> VkPipelineInputAssemblyStateCreateFlags -> IO ())
-> (Ptr VkPipelineInputAssemblyStateCreateFlags
    -> IO VkPipelineInputAssemblyStateCreateFlags)
-> (Ptr VkPipelineInputAssemblyStateCreateFlags
    -> VkPipelineInputAssemblyStateCreateFlags -> IO ())
-> Storable VkPipelineInputAssemblyStateCreateFlags
forall b.
Ptr b -> Int -> IO VkPipelineInputAssemblyStateCreateFlags
forall b.
Ptr b -> Int -> VkPipelineInputAssemblyStateCreateFlags -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr VkPipelineInputAssemblyStateCreateFlags
-> VkPipelineInputAssemblyStateCreateFlags -> IO ()
$cpoke :: Ptr VkPipelineInputAssemblyStateCreateFlags
-> VkPipelineInputAssemblyStateCreateFlags -> IO ()
peek :: Ptr VkPipelineInputAssemblyStateCreateFlags
-> IO VkPipelineInputAssemblyStateCreateFlags
$cpeek :: Ptr VkPipelineInputAssemblyStateCreateFlags
-> IO VkPipelineInputAssemblyStateCreateFlags
pokeByteOff :: forall b.
Ptr b -> Int -> VkPipelineInputAssemblyStateCreateFlags -> IO ()
$cpokeByteOff :: forall b.
Ptr b -> Int -> VkPipelineInputAssemblyStateCreateFlags -> IO ()
peekByteOff :: forall b.
Ptr b -> Int -> IO VkPipelineInputAssemblyStateCreateFlags
$cpeekByteOff :: forall b.
Ptr b -> Int -> IO VkPipelineInputAssemblyStateCreateFlags
pokeElemOff :: Ptr VkPipelineInputAssemblyStateCreateFlags
-> Int -> VkPipelineInputAssemblyStateCreateFlags -> IO ()
$cpokeElemOff :: Ptr VkPipelineInputAssemblyStateCreateFlags
-> Int -> VkPipelineInputAssemblyStateCreateFlags -> IO ()
peekElemOff :: Ptr VkPipelineInputAssemblyStateCreateFlags
-> Int -> IO VkPipelineInputAssemblyStateCreateFlags
$cpeekElemOff :: Ptr VkPipelineInputAssemblyStateCreateFlags
-> Int -> IO VkPipelineInputAssemblyStateCreateFlags
alignment :: VkPipelineInputAssemblyStateCreateFlags -> Int
$calignment :: VkPipelineInputAssemblyStateCreateFlags -> Int
sizeOf :: VkPipelineInputAssemblyStateCreateFlags -> Int
$csizeOf :: VkPipelineInputAssemblyStateCreateFlags -> Int
Storable)

instance Show VkPipelineInputAssemblyStateCreateFlags where
    {-# INLINE showsPrec #-}
    showsPrec :: Int -> VkPipelineInputAssemblyStateCreateFlags -> ShowS
showsPrec = (Int -> VkFlags -> ShowS)
-> Int -> VkPipelineInputAssemblyStateCreateFlags -> ShowS
coerce (Int -> VkFlags -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec :: Int -> VkFlags -> ShowS)

instance Read VkPipelineInputAssemblyStateCreateFlags where
    {-# INLINE readsPrec #-}
    readsPrec :: Int -> ReadS VkPipelineInputAssemblyStateCreateFlags
readsPrec = (Int -> ReadS VkFlags)
-> Int -> ReadS VkPipelineInputAssemblyStateCreateFlags
coerce (Int -> ReadS VkFlags
forall a. Read a => Int -> ReadS a
readsPrec :: Int -> ReadS VkFlags)

newtype VkPipelineLayoutCreateFlags = VkPipelineLayoutCreateFlags VkFlags
                                      deriving (VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags -> Bool
(VkPipelineLayoutCreateFlags
 -> VkPipelineLayoutCreateFlags -> Bool)
-> (VkPipelineLayoutCreateFlags
    -> VkPipelineLayoutCreateFlags -> Bool)
-> Eq VkPipelineLayoutCreateFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags -> Bool
$c/= :: VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags -> Bool
== :: VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags -> Bool
$c== :: VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags -> Bool
Eq, Eq VkPipelineLayoutCreateFlags
Eq VkPipelineLayoutCreateFlags
-> (VkPipelineLayoutCreateFlags
    -> VkPipelineLayoutCreateFlags -> Ordering)
-> (VkPipelineLayoutCreateFlags
    -> VkPipelineLayoutCreateFlags -> Bool)
-> (VkPipelineLayoutCreateFlags
    -> VkPipelineLayoutCreateFlags -> Bool)
-> (VkPipelineLayoutCreateFlags
    -> VkPipelineLayoutCreateFlags -> Bool)
-> (VkPipelineLayoutCreateFlags
    -> VkPipelineLayoutCreateFlags -> Bool)
-> (VkPipelineLayoutCreateFlags
    -> VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags)
-> (VkPipelineLayoutCreateFlags
    -> VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags)
-> Ord VkPipelineLayoutCreateFlags
VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags -> Bool
VkPipelineLayoutCreateFlags
-> VkPipelineLayoutCreateFlags -> Ordering
VkPipelineLayoutCreateFlags
-> VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: VkPipelineLayoutCreateFlags
-> VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags
$cmin :: VkPipelineLayoutCreateFlags
-> VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags
max :: VkPipelineLayoutCreateFlags
-> VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags
$cmax :: VkPipelineLayoutCreateFlags
-> VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags
>= :: VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags -> Bool
$c>= :: VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags -> Bool
> :: VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags -> Bool
$c> :: VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags -> Bool
<= :: VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags -> Bool
$c<= :: VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags -> Bool
< :: VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags -> Bool
$c< :: VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags -> Bool
compare :: VkPipelineLayoutCreateFlags
-> VkPipelineLayoutCreateFlags -> Ordering
$ccompare :: VkPipelineLayoutCreateFlags
-> VkPipelineLayoutCreateFlags -> Ordering
Ord, Int -> VkPipelineLayoutCreateFlags
VkPipelineLayoutCreateFlags -> Int
VkPipelineLayoutCreateFlags -> [VkPipelineLayoutCreateFlags]
VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags
VkPipelineLayoutCreateFlags
-> VkPipelineLayoutCreateFlags -> [VkPipelineLayoutCreateFlags]
VkPipelineLayoutCreateFlags
-> VkPipelineLayoutCreateFlags
-> VkPipelineLayoutCreateFlags
-> [VkPipelineLayoutCreateFlags]
(VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags)
-> (VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags)
-> (Int -> VkPipelineLayoutCreateFlags)
-> (VkPipelineLayoutCreateFlags -> Int)
-> (VkPipelineLayoutCreateFlags -> [VkPipelineLayoutCreateFlags])
-> (VkPipelineLayoutCreateFlags
    -> VkPipelineLayoutCreateFlags -> [VkPipelineLayoutCreateFlags])
-> (VkPipelineLayoutCreateFlags
    -> VkPipelineLayoutCreateFlags -> [VkPipelineLayoutCreateFlags])
-> (VkPipelineLayoutCreateFlags
    -> VkPipelineLayoutCreateFlags
    -> VkPipelineLayoutCreateFlags
    -> [VkPipelineLayoutCreateFlags])
-> Enum VkPipelineLayoutCreateFlags
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: VkPipelineLayoutCreateFlags
-> VkPipelineLayoutCreateFlags
-> VkPipelineLayoutCreateFlags
-> [VkPipelineLayoutCreateFlags]
$cenumFromThenTo :: VkPipelineLayoutCreateFlags
-> VkPipelineLayoutCreateFlags
-> VkPipelineLayoutCreateFlags
-> [VkPipelineLayoutCreateFlags]
enumFromTo :: VkPipelineLayoutCreateFlags
-> VkPipelineLayoutCreateFlags -> [VkPipelineLayoutCreateFlags]
$cenumFromTo :: VkPipelineLayoutCreateFlags
-> VkPipelineLayoutCreateFlags -> [VkPipelineLayoutCreateFlags]
enumFromThen :: VkPipelineLayoutCreateFlags
-> VkPipelineLayoutCreateFlags -> [VkPipelineLayoutCreateFlags]
$cenumFromThen :: VkPipelineLayoutCreateFlags
-> VkPipelineLayoutCreateFlags -> [VkPipelineLayoutCreateFlags]
enumFrom :: VkPipelineLayoutCreateFlags -> [VkPipelineLayoutCreateFlags]
$cenumFrom :: VkPipelineLayoutCreateFlags -> [VkPipelineLayoutCreateFlags]
fromEnum :: VkPipelineLayoutCreateFlags -> Int
$cfromEnum :: VkPipelineLayoutCreateFlags -> Int
toEnum :: Int -> VkPipelineLayoutCreateFlags
$ctoEnum :: Int -> VkPipelineLayoutCreateFlags
pred :: VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags
$cpred :: VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags
succ :: VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags
$csucc :: VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags
Enum, Eq VkPipelineLayoutCreateFlags
VkPipelineLayoutCreateFlags
Eq VkPipelineLayoutCreateFlags
-> (VkPipelineLayoutCreateFlags
    -> VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags)
-> (VkPipelineLayoutCreateFlags
    -> VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags)
-> (VkPipelineLayoutCreateFlags
    -> VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags)
-> (VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags)
-> (VkPipelineLayoutCreateFlags
    -> Int -> VkPipelineLayoutCreateFlags)
-> (VkPipelineLayoutCreateFlags
    -> Int -> VkPipelineLayoutCreateFlags)
-> VkPipelineLayoutCreateFlags
-> (Int -> VkPipelineLayoutCreateFlags)
-> (VkPipelineLayoutCreateFlags
    -> Int -> VkPipelineLayoutCreateFlags)
-> (VkPipelineLayoutCreateFlags
    -> Int -> VkPipelineLayoutCreateFlags)
-> (VkPipelineLayoutCreateFlags
    -> Int -> VkPipelineLayoutCreateFlags)
-> (VkPipelineLayoutCreateFlags -> Int -> Bool)
-> (VkPipelineLayoutCreateFlags -> Maybe Int)
-> (VkPipelineLayoutCreateFlags -> Int)
-> (VkPipelineLayoutCreateFlags -> Bool)
-> (VkPipelineLayoutCreateFlags
    -> Int -> VkPipelineLayoutCreateFlags)
-> (VkPipelineLayoutCreateFlags
    -> Int -> VkPipelineLayoutCreateFlags)
-> (VkPipelineLayoutCreateFlags
    -> Int -> VkPipelineLayoutCreateFlags)
-> (VkPipelineLayoutCreateFlags
    -> Int -> VkPipelineLayoutCreateFlags)
-> (VkPipelineLayoutCreateFlags
    -> Int -> VkPipelineLayoutCreateFlags)
-> (VkPipelineLayoutCreateFlags
    -> Int -> VkPipelineLayoutCreateFlags)
-> (VkPipelineLayoutCreateFlags -> Int)
-> Bits VkPipelineLayoutCreateFlags
Int -> VkPipelineLayoutCreateFlags
VkPipelineLayoutCreateFlags -> Bool
VkPipelineLayoutCreateFlags -> Int
VkPipelineLayoutCreateFlags -> Maybe Int
VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags
VkPipelineLayoutCreateFlags -> Int -> Bool
VkPipelineLayoutCreateFlags -> Int -> VkPipelineLayoutCreateFlags
VkPipelineLayoutCreateFlags
-> VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags
forall a.
Eq a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
popCount :: VkPipelineLayoutCreateFlags -> Int
$cpopCount :: VkPipelineLayoutCreateFlags -> Int
rotateR :: VkPipelineLayoutCreateFlags -> Int -> VkPipelineLayoutCreateFlags
$crotateR :: VkPipelineLayoutCreateFlags -> Int -> VkPipelineLayoutCreateFlags
rotateL :: VkPipelineLayoutCreateFlags -> Int -> VkPipelineLayoutCreateFlags
$crotateL :: VkPipelineLayoutCreateFlags -> Int -> VkPipelineLayoutCreateFlags
unsafeShiftR :: VkPipelineLayoutCreateFlags -> Int -> VkPipelineLayoutCreateFlags
$cunsafeShiftR :: VkPipelineLayoutCreateFlags -> Int -> VkPipelineLayoutCreateFlags
shiftR :: VkPipelineLayoutCreateFlags -> Int -> VkPipelineLayoutCreateFlags
$cshiftR :: VkPipelineLayoutCreateFlags -> Int -> VkPipelineLayoutCreateFlags
unsafeShiftL :: VkPipelineLayoutCreateFlags -> Int -> VkPipelineLayoutCreateFlags
$cunsafeShiftL :: VkPipelineLayoutCreateFlags -> Int -> VkPipelineLayoutCreateFlags
shiftL :: VkPipelineLayoutCreateFlags -> Int -> VkPipelineLayoutCreateFlags
$cshiftL :: VkPipelineLayoutCreateFlags -> Int -> VkPipelineLayoutCreateFlags
isSigned :: VkPipelineLayoutCreateFlags -> Bool
$cisSigned :: VkPipelineLayoutCreateFlags -> Bool
bitSize :: VkPipelineLayoutCreateFlags -> Int
$cbitSize :: VkPipelineLayoutCreateFlags -> Int
bitSizeMaybe :: VkPipelineLayoutCreateFlags -> Maybe Int
$cbitSizeMaybe :: VkPipelineLayoutCreateFlags -> Maybe Int
testBit :: VkPipelineLayoutCreateFlags -> Int -> Bool
$ctestBit :: VkPipelineLayoutCreateFlags -> Int -> Bool
complementBit :: VkPipelineLayoutCreateFlags -> Int -> VkPipelineLayoutCreateFlags
$ccomplementBit :: VkPipelineLayoutCreateFlags -> Int -> VkPipelineLayoutCreateFlags
clearBit :: VkPipelineLayoutCreateFlags -> Int -> VkPipelineLayoutCreateFlags
$cclearBit :: VkPipelineLayoutCreateFlags -> Int -> VkPipelineLayoutCreateFlags
setBit :: VkPipelineLayoutCreateFlags -> Int -> VkPipelineLayoutCreateFlags
$csetBit :: VkPipelineLayoutCreateFlags -> Int -> VkPipelineLayoutCreateFlags
bit :: Int -> VkPipelineLayoutCreateFlags
$cbit :: Int -> VkPipelineLayoutCreateFlags
zeroBits :: VkPipelineLayoutCreateFlags
$czeroBits :: VkPipelineLayoutCreateFlags
rotate :: VkPipelineLayoutCreateFlags -> Int -> VkPipelineLayoutCreateFlags
$crotate :: VkPipelineLayoutCreateFlags -> Int -> VkPipelineLayoutCreateFlags
shift :: VkPipelineLayoutCreateFlags -> Int -> VkPipelineLayoutCreateFlags
$cshift :: VkPipelineLayoutCreateFlags -> Int -> VkPipelineLayoutCreateFlags
complement :: VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags
$ccomplement :: VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags
xor :: VkPipelineLayoutCreateFlags
-> VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags
$cxor :: VkPipelineLayoutCreateFlags
-> VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags
.|. :: VkPipelineLayoutCreateFlags
-> VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags
$c.|. :: VkPipelineLayoutCreateFlags
-> VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags
.&. :: VkPipelineLayoutCreateFlags
-> VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags
$c.&. :: VkPipelineLayoutCreateFlags
-> VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags
Bits, Bits VkPipelineLayoutCreateFlags
Bits VkPipelineLayoutCreateFlags
-> (VkPipelineLayoutCreateFlags -> Int)
-> (VkPipelineLayoutCreateFlags -> Int)
-> (VkPipelineLayoutCreateFlags -> Int)
-> FiniteBits VkPipelineLayoutCreateFlags
VkPipelineLayoutCreateFlags -> Int
forall b.
Bits b -> (b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
countTrailingZeros :: VkPipelineLayoutCreateFlags -> Int
$ccountTrailingZeros :: VkPipelineLayoutCreateFlags -> Int
countLeadingZeros :: VkPipelineLayoutCreateFlags -> Int
$ccountLeadingZeros :: VkPipelineLayoutCreateFlags -> Int
finiteBitSize :: VkPipelineLayoutCreateFlags -> Int
$cfiniteBitSize :: VkPipelineLayoutCreateFlags -> Int
FiniteBits, Ptr VkPipelineLayoutCreateFlags -> IO VkPipelineLayoutCreateFlags
Ptr VkPipelineLayoutCreateFlags
-> Int -> IO VkPipelineLayoutCreateFlags
Ptr VkPipelineLayoutCreateFlags
-> Int -> VkPipelineLayoutCreateFlags -> IO ()
Ptr VkPipelineLayoutCreateFlags
-> VkPipelineLayoutCreateFlags -> IO ()
VkPipelineLayoutCreateFlags -> Int
(VkPipelineLayoutCreateFlags -> Int)
-> (VkPipelineLayoutCreateFlags -> Int)
-> (Ptr VkPipelineLayoutCreateFlags
    -> Int -> IO VkPipelineLayoutCreateFlags)
-> (Ptr VkPipelineLayoutCreateFlags
    -> Int -> VkPipelineLayoutCreateFlags -> IO ())
-> (forall b. Ptr b -> Int -> IO VkPipelineLayoutCreateFlags)
-> (forall b. Ptr b -> Int -> VkPipelineLayoutCreateFlags -> IO ())
-> (Ptr VkPipelineLayoutCreateFlags
    -> IO VkPipelineLayoutCreateFlags)
-> (Ptr VkPipelineLayoutCreateFlags
    -> VkPipelineLayoutCreateFlags -> IO ())
-> Storable VkPipelineLayoutCreateFlags
forall b. Ptr b -> Int -> IO VkPipelineLayoutCreateFlags
forall b. Ptr b -> Int -> VkPipelineLayoutCreateFlags -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr VkPipelineLayoutCreateFlags
-> VkPipelineLayoutCreateFlags -> IO ()
$cpoke :: Ptr VkPipelineLayoutCreateFlags
-> VkPipelineLayoutCreateFlags -> IO ()
peek :: Ptr VkPipelineLayoutCreateFlags -> IO VkPipelineLayoutCreateFlags
$cpeek :: Ptr VkPipelineLayoutCreateFlags -> IO VkPipelineLayoutCreateFlags
pokeByteOff :: forall b. Ptr b -> Int -> VkPipelineLayoutCreateFlags -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> VkPipelineLayoutCreateFlags -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO VkPipelineLayoutCreateFlags
$cpeekByteOff :: forall b. Ptr b -> Int -> IO VkPipelineLayoutCreateFlags
pokeElemOff :: Ptr VkPipelineLayoutCreateFlags
-> Int -> VkPipelineLayoutCreateFlags -> IO ()
$cpokeElemOff :: Ptr VkPipelineLayoutCreateFlags
-> Int -> VkPipelineLayoutCreateFlags -> IO ()
peekElemOff :: Ptr VkPipelineLayoutCreateFlags
-> Int -> IO VkPipelineLayoutCreateFlags
$cpeekElemOff :: Ptr VkPipelineLayoutCreateFlags
-> Int -> IO VkPipelineLayoutCreateFlags
alignment :: VkPipelineLayoutCreateFlags -> Int
$calignment :: VkPipelineLayoutCreateFlags -> Int
sizeOf :: VkPipelineLayoutCreateFlags -> Int
$csizeOf :: VkPipelineLayoutCreateFlags -> Int
Storable)

instance Show VkPipelineLayoutCreateFlags where
    {-# INLINE showsPrec #-}
    showsPrec :: Int -> VkPipelineLayoutCreateFlags -> ShowS
showsPrec = (Int -> VkFlags -> ShowS)
-> Int -> VkPipelineLayoutCreateFlags -> ShowS
coerce (Int -> VkFlags -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec :: Int -> VkFlags -> ShowS)

instance Read VkPipelineLayoutCreateFlags where
    {-# INLINE readsPrec #-}
    readsPrec :: Int -> ReadS VkPipelineLayoutCreateFlags
readsPrec = (Int -> ReadS VkFlags) -> Int -> ReadS VkPipelineLayoutCreateFlags
coerce (Int -> ReadS VkFlags
forall a. Read a => Int -> ReadS a
readsPrec :: Int -> ReadS VkFlags)

newtype VkPipelineMultisampleStateCreateFlags = VkPipelineMultisampleStateCreateFlags VkFlags
                                                deriving (VkPipelineMultisampleStateCreateFlags
-> VkPipelineMultisampleStateCreateFlags -> Bool
(VkPipelineMultisampleStateCreateFlags
 -> VkPipelineMultisampleStateCreateFlags -> Bool)
-> (VkPipelineMultisampleStateCreateFlags
    -> VkPipelineMultisampleStateCreateFlags -> Bool)
-> Eq VkPipelineMultisampleStateCreateFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VkPipelineMultisampleStateCreateFlags
-> VkPipelineMultisampleStateCreateFlags -> Bool
$c/= :: VkPipelineMultisampleStateCreateFlags
-> VkPipelineMultisampleStateCreateFlags -> Bool
== :: VkPipelineMultisampleStateCreateFlags
-> VkPipelineMultisampleStateCreateFlags -> Bool
$c== :: VkPipelineMultisampleStateCreateFlags
-> VkPipelineMultisampleStateCreateFlags -> Bool
Eq, Eq VkPipelineMultisampleStateCreateFlags
Eq VkPipelineMultisampleStateCreateFlags
-> (VkPipelineMultisampleStateCreateFlags
    -> VkPipelineMultisampleStateCreateFlags -> Ordering)
-> (VkPipelineMultisampleStateCreateFlags
    -> VkPipelineMultisampleStateCreateFlags -> Bool)
-> (VkPipelineMultisampleStateCreateFlags
    -> VkPipelineMultisampleStateCreateFlags -> Bool)
-> (VkPipelineMultisampleStateCreateFlags
    -> VkPipelineMultisampleStateCreateFlags -> Bool)
-> (VkPipelineMultisampleStateCreateFlags
    -> VkPipelineMultisampleStateCreateFlags -> Bool)
-> (VkPipelineMultisampleStateCreateFlags
    -> VkPipelineMultisampleStateCreateFlags
    -> VkPipelineMultisampleStateCreateFlags)
-> (VkPipelineMultisampleStateCreateFlags
    -> VkPipelineMultisampleStateCreateFlags
    -> VkPipelineMultisampleStateCreateFlags)
-> Ord VkPipelineMultisampleStateCreateFlags
VkPipelineMultisampleStateCreateFlags
-> VkPipelineMultisampleStateCreateFlags -> Bool
VkPipelineMultisampleStateCreateFlags
-> VkPipelineMultisampleStateCreateFlags -> Ordering
VkPipelineMultisampleStateCreateFlags
-> VkPipelineMultisampleStateCreateFlags
-> VkPipelineMultisampleStateCreateFlags
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: VkPipelineMultisampleStateCreateFlags
-> VkPipelineMultisampleStateCreateFlags
-> VkPipelineMultisampleStateCreateFlags
$cmin :: VkPipelineMultisampleStateCreateFlags
-> VkPipelineMultisampleStateCreateFlags
-> VkPipelineMultisampleStateCreateFlags
max :: VkPipelineMultisampleStateCreateFlags
-> VkPipelineMultisampleStateCreateFlags
-> VkPipelineMultisampleStateCreateFlags
$cmax :: VkPipelineMultisampleStateCreateFlags
-> VkPipelineMultisampleStateCreateFlags
-> VkPipelineMultisampleStateCreateFlags
>= :: VkPipelineMultisampleStateCreateFlags
-> VkPipelineMultisampleStateCreateFlags -> Bool
$c>= :: VkPipelineMultisampleStateCreateFlags
-> VkPipelineMultisampleStateCreateFlags -> Bool
> :: VkPipelineMultisampleStateCreateFlags
-> VkPipelineMultisampleStateCreateFlags -> Bool
$c> :: VkPipelineMultisampleStateCreateFlags
-> VkPipelineMultisampleStateCreateFlags -> Bool
<= :: VkPipelineMultisampleStateCreateFlags
-> VkPipelineMultisampleStateCreateFlags -> Bool
$c<= :: VkPipelineMultisampleStateCreateFlags
-> VkPipelineMultisampleStateCreateFlags -> Bool
< :: VkPipelineMultisampleStateCreateFlags
-> VkPipelineMultisampleStateCreateFlags -> Bool
$c< :: VkPipelineMultisampleStateCreateFlags
-> VkPipelineMultisampleStateCreateFlags -> Bool
compare :: VkPipelineMultisampleStateCreateFlags
-> VkPipelineMultisampleStateCreateFlags -> Ordering
$ccompare :: VkPipelineMultisampleStateCreateFlags
-> VkPipelineMultisampleStateCreateFlags -> Ordering
Ord, Int -> VkPipelineMultisampleStateCreateFlags
VkPipelineMultisampleStateCreateFlags -> Int
VkPipelineMultisampleStateCreateFlags
-> [VkPipelineMultisampleStateCreateFlags]
VkPipelineMultisampleStateCreateFlags
-> VkPipelineMultisampleStateCreateFlags
VkPipelineMultisampleStateCreateFlags
-> VkPipelineMultisampleStateCreateFlags
-> [VkPipelineMultisampleStateCreateFlags]
VkPipelineMultisampleStateCreateFlags
-> VkPipelineMultisampleStateCreateFlags
-> VkPipelineMultisampleStateCreateFlags
-> [VkPipelineMultisampleStateCreateFlags]
(VkPipelineMultisampleStateCreateFlags
 -> VkPipelineMultisampleStateCreateFlags)
-> (VkPipelineMultisampleStateCreateFlags
    -> VkPipelineMultisampleStateCreateFlags)
-> (Int -> VkPipelineMultisampleStateCreateFlags)
-> (VkPipelineMultisampleStateCreateFlags -> Int)
-> (VkPipelineMultisampleStateCreateFlags
    -> [VkPipelineMultisampleStateCreateFlags])
-> (VkPipelineMultisampleStateCreateFlags
    -> VkPipelineMultisampleStateCreateFlags
    -> [VkPipelineMultisampleStateCreateFlags])
-> (VkPipelineMultisampleStateCreateFlags
    -> VkPipelineMultisampleStateCreateFlags
    -> [VkPipelineMultisampleStateCreateFlags])
-> (VkPipelineMultisampleStateCreateFlags
    -> VkPipelineMultisampleStateCreateFlags
    -> VkPipelineMultisampleStateCreateFlags
    -> [VkPipelineMultisampleStateCreateFlags])
-> Enum VkPipelineMultisampleStateCreateFlags
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: VkPipelineMultisampleStateCreateFlags
-> VkPipelineMultisampleStateCreateFlags
-> VkPipelineMultisampleStateCreateFlags
-> [VkPipelineMultisampleStateCreateFlags]
$cenumFromThenTo :: VkPipelineMultisampleStateCreateFlags
-> VkPipelineMultisampleStateCreateFlags
-> VkPipelineMultisampleStateCreateFlags
-> [VkPipelineMultisampleStateCreateFlags]
enumFromTo :: VkPipelineMultisampleStateCreateFlags
-> VkPipelineMultisampleStateCreateFlags
-> [VkPipelineMultisampleStateCreateFlags]
$cenumFromTo :: VkPipelineMultisampleStateCreateFlags
-> VkPipelineMultisampleStateCreateFlags
-> [VkPipelineMultisampleStateCreateFlags]
enumFromThen :: VkPipelineMultisampleStateCreateFlags
-> VkPipelineMultisampleStateCreateFlags
-> [VkPipelineMultisampleStateCreateFlags]
$cenumFromThen :: VkPipelineMultisampleStateCreateFlags
-> VkPipelineMultisampleStateCreateFlags
-> [VkPipelineMultisampleStateCreateFlags]
enumFrom :: VkPipelineMultisampleStateCreateFlags
-> [VkPipelineMultisampleStateCreateFlags]
$cenumFrom :: VkPipelineMultisampleStateCreateFlags
-> [VkPipelineMultisampleStateCreateFlags]
fromEnum :: VkPipelineMultisampleStateCreateFlags -> Int
$cfromEnum :: VkPipelineMultisampleStateCreateFlags -> Int
toEnum :: Int -> VkPipelineMultisampleStateCreateFlags
$ctoEnum :: Int -> VkPipelineMultisampleStateCreateFlags
pred :: VkPipelineMultisampleStateCreateFlags
-> VkPipelineMultisampleStateCreateFlags
$cpred :: VkPipelineMultisampleStateCreateFlags
-> VkPipelineMultisampleStateCreateFlags
succ :: VkPipelineMultisampleStateCreateFlags
-> VkPipelineMultisampleStateCreateFlags
$csucc :: VkPipelineMultisampleStateCreateFlags
-> VkPipelineMultisampleStateCreateFlags
Enum, Eq VkPipelineMultisampleStateCreateFlags
VkPipelineMultisampleStateCreateFlags
Eq VkPipelineMultisampleStateCreateFlags
-> (VkPipelineMultisampleStateCreateFlags
    -> VkPipelineMultisampleStateCreateFlags
    -> VkPipelineMultisampleStateCreateFlags)
-> (VkPipelineMultisampleStateCreateFlags
    -> VkPipelineMultisampleStateCreateFlags
    -> VkPipelineMultisampleStateCreateFlags)
-> (VkPipelineMultisampleStateCreateFlags
    -> VkPipelineMultisampleStateCreateFlags
    -> VkPipelineMultisampleStateCreateFlags)
-> (VkPipelineMultisampleStateCreateFlags
    -> VkPipelineMultisampleStateCreateFlags)
-> (VkPipelineMultisampleStateCreateFlags
    -> Int -> VkPipelineMultisampleStateCreateFlags)
-> (VkPipelineMultisampleStateCreateFlags
    -> Int -> VkPipelineMultisampleStateCreateFlags)
-> VkPipelineMultisampleStateCreateFlags
-> (Int -> VkPipelineMultisampleStateCreateFlags)
-> (VkPipelineMultisampleStateCreateFlags
    -> Int -> VkPipelineMultisampleStateCreateFlags)
-> (VkPipelineMultisampleStateCreateFlags
    -> Int -> VkPipelineMultisampleStateCreateFlags)
-> (VkPipelineMultisampleStateCreateFlags
    -> Int -> VkPipelineMultisampleStateCreateFlags)
-> (VkPipelineMultisampleStateCreateFlags -> Int -> Bool)
-> (VkPipelineMultisampleStateCreateFlags -> Maybe Int)
-> (VkPipelineMultisampleStateCreateFlags -> Int)
-> (VkPipelineMultisampleStateCreateFlags -> Bool)
-> (VkPipelineMultisampleStateCreateFlags
    -> Int -> VkPipelineMultisampleStateCreateFlags)
-> (VkPipelineMultisampleStateCreateFlags
    -> Int -> VkPipelineMultisampleStateCreateFlags)
-> (VkPipelineMultisampleStateCreateFlags
    -> Int -> VkPipelineMultisampleStateCreateFlags)
-> (VkPipelineMultisampleStateCreateFlags
    -> Int -> VkPipelineMultisampleStateCreateFlags)
-> (VkPipelineMultisampleStateCreateFlags
    -> Int -> VkPipelineMultisampleStateCreateFlags)
-> (VkPipelineMultisampleStateCreateFlags
    -> Int -> VkPipelineMultisampleStateCreateFlags)
-> (VkPipelineMultisampleStateCreateFlags -> Int)
-> Bits VkPipelineMultisampleStateCreateFlags
Int -> VkPipelineMultisampleStateCreateFlags
VkPipelineMultisampleStateCreateFlags -> Bool
VkPipelineMultisampleStateCreateFlags -> Int
VkPipelineMultisampleStateCreateFlags -> Maybe Int
VkPipelineMultisampleStateCreateFlags
-> VkPipelineMultisampleStateCreateFlags
VkPipelineMultisampleStateCreateFlags -> Int -> Bool
VkPipelineMultisampleStateCreateFlags
-> Int -> VkPipelineMultisampleStateCreateFlags
VkPipelineMultisampleStateCreateFlags
-> VkPipelineMultisampleStateCreateFlags
-> VkPipelineMultisampleStateCreateFlags
forall a.
Eq a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
popCount :: VkPipelineMultisampleStateCreateFlags -> Int
$cpopCount :: VkPipelineMultisampleStateCreateFlags -> Int
rotateR :: VkPipelineMultisampleStateCreateFlags
-> Int -> VkPipelineMultisampleStateCreateFlags
$crotateR :: VkPipelineMultisampleStateCreateFlags
-> Int -> VkPipelineMultisampleStateCreateFlags
rotateL :: VkPipelineMultisampleStateCreateFlags
-> Int -> VkPipelineMultisampleStateCreateFlags
$crotateL :: VkPipelineMultisampleStateCreateFlags
-> Int -> VkPipelineMultisampleStateCreateFlags
unsafeShiftR :: VkPipelineMultisampleStateCreateFlags
-> Int -> VkPipelineMultisampleStateCreateFlags
$cunsafeShiftR :: VkPipelineMultisampleStateCreateFlags
-> Int -> VkPipelineMultisampleStateCreateFlags
shiftR :: VkPipelineMultisampleStateCreateFlags
-> Int -> VkPipelineMultisampleStateCreateFlags
$cshiftR :: VkPipelineMultisampleStateCreateFlags
-> Int -> VkPipelineMultisampleStateCreateFlags
unsafeShiftL :: VkPipelineMultisampleStateCreateFlags
-> Int -> VkPipelineMultisampleStateCreateFlags
$cunsafeShiftL :: VkPipelineMultisampleStateCreateFlags
-> Int -> VkPipelineMultisampleStateCreateFlags
shiftL :: VkPipelineMultisampleStateCreateFlags
-> Int -> VkPipelineMultisampleStateCreateFlags
$cshiftL :: VkPipelineMultisampleStateCreateFlags
-> Int -> VkPipelineMultisampleStateCreateFlags
isSigned :: VkPipelineMultisampleStateCreateFlags -> Bool
$cisSigned :: VkPipelineMultisampleStateCreateFlags -> Bool
bitSize :: VkPipelineMultisampleStateCreateFlags -> Int
$cbitSize :: VkPipelineMultisampleStateCreateFlags -> Int
bitSizeMaybe :: VkPipelineMultisampleStateCreateFlags -> Maybe Int
$cbitSizeMaybe :: VkPipelineMultisampleStateCreateFlags -> Maybe Int
testBit :: VkPipelineMultisampleStateCreateFlags -> Int -> Bool
$ctestBit :: VkPipelineMultisampleStateCreateFlags -> Int -> Bool
complementBit :: VkPipelineMultisampleStateCreateFlags
-> Int -> VkPipelineMultisampleStateCreateFlags
$ccomplementBit :: VkPipelineMultisampleStateCreateFlags
-> Int -> VkPipelineMultisampleStateCreateFlags
clearBit :: VkPipelineMultisampleStateCreateFlags
-> Int -> VkPipelineMultisampleStateCreateFlags
$cclearBit :: VkPipelineMultisampleStateCreateFlags
-> Int -> VkPipelineMultisampleStateCreateFlags
setBit :: VkPipelineMultisampleStateCreateFlags
-> Int -> VkPipelineMultisampleStateCreateFlags
$csetBit :: VkPipelineMultisampleStateCreateFlags
-> Int -> VkPipelineMultisampleStateCreateFlags
bit :: Int -> VkPipelineMultisampleStateCreateFlags
$cbit :: Int -> VkPipelineMultisampleStateCreateFlags
zeroBits :: VkPipelineMultisampleStateCreateFlags
$czeroBits :: VkPipelineMultisampleStateCreateFlags
rotate :: VkPipelineMultisampleStateCreateFlags
-> Int -> VkPipelineMultisampleStateCreateFlags
$crotate :: VkPipelineMultisampleStateCreateFlags
-> Int -> VkPipelineMultisampleStateCreateFlags
shift :: VkPipelineMultisampleStateCreateFlags
-> Int -> VkPipelineMultisampleStateCreateFlags
$cshift :: VkPipelineMultisampleStateCreateFlags
-> Int -> VkPipelineMultisampleStateCreateFlags
complement :: VkPipelineMultisampleStateCreateFlags
-> VkPipelineMultisampleStateCreateFlags
$ccomplement :: VkPipelineMultisampleStateCreateFlags
-> VkPipelineMultisampleStateCreateFlags
xor :: VkPipelineMultisampleStateCreateFlags
-> VkPipelineMultisampleStateCreateFlags
-> VkPipelineMultisampleStateCreateFlags
$cxor :: VkPipelineMultisampleStateCreateFlags
-> VkPipelineMultisampleStateCreateFlags
-> VkPipelineMultisampleStateCreateFlags
.|. :: VkPipelineMultisampleStateCreateFlags
-> VkPipelineMultisampleStateCreateFlags
-> VkPipelineMultisampleStateCreateFlags
$c.|. :: VkPipelineMultisampleStateCreateFlags
-> VkPipelineMultisampleStateCreateFlags
-> VkPipelineMultisampleStateCreateFlags
.&. :: VkPipelineMultisampleStateCreateFlags
-> VkPipelineMultisampleStateCreateFlags
-> VkPipelineMultisampleStateCreateFlags
$c.&. :: VkPipelineMultisampleStateCreateFlags
-> VkPipelineMultisampleStateCreateFlags
-> VkPipelineMultisampleStateCreateFlags
Bits, Bits VkPipelineMultisampleStateCreateFlags
Bits VkPipelineMultisampleStateCreateFlags
-> (VkPipelineMultisampleStateCreateFlags -> Int)
-> (VkPipelineMultisampleStateCreateFlags -> Int)
-> (VkPipelineMultisampleStateCreateFlags -> Int)
-> FiniteBits VkPipelineMultisampleStateCreateFlags
VkPipelineMultisampleStateCreateFlags -> Int
forall b.
Bits b -> (b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
countTrailingZeros :: VkPipelineMultisampleStateCreateFlags -> Int
$ccountTrailingZeros :: VkPipelineMultisampleStateCreateFlags -> Int
countLeadingZeros :: VkPipelineMultisampleStateCreateFlags -> Int
$ccountLeadingZeros :: VkPipelineMultisampleStateCreateFlags -> Int
finiteBitSize :: VkPipelineMultisampleStateCreateFlags -> Int
$cfiniteBitSize :: VkPipelineMultisampleStateCreateFlags -> Int
FiniteBits, Ptr VkPipelineMultisampleStateCreateFlags
-> IO VkPipelineMultisampleStateCreateFlags
Ptr VkPipelineMultisampleStateCreateFlags
-> Int -> IO VkPipelineMultisampleStateCreateFlags
Ptr VkPipelineMultisampleStateCreateFlags
-> Int -> VkPipelineMultisampleStateCreateFlags -> IO ()
Ptr VkPipelineMultisampleStateCreateFlags
-> VkPipelineMultisampleStateCreateFlags -> IO ()
VkPipelineMultisampleStateCreateFlags -> Int
(VkPipelineMultisampleStateCreateFlags -> Int)
-> (VkPipelineMultisampleStateCreateFlags -> Int)
-> (Ptr VkPipelineMultisampleStateCreateFlags
    -> Int -> IO VkPipelineMultisampleStateCreateFlags)
-> (Ptr VkPipelineMultisampleStateCreateFlags
    -> Int -> VkPipelineMultisampleStateCreateFlags -> IO ())
-> (forall b.
    Ptr b -> Int -> IO VkPipelineMultisampleStateCreateFlags)
-> (forall b.
    Ptr b -> Int -> VkPipelineMultisampleStateCreateFlags -> IO ())
-> (Ptr VkPipelineMultisampleStateCreateFlags
    -> IO VkPipelineMultisampleStateCreateFlags)
-> (Ptr VkPipelineMultisampleStateCreateFlags
    -> VkPipelineMultisampleStateCreateFlags -> IO ())
-> Storable VkPipelineMultisampleStateCreateFlags
forall b. Ptr b -> Int -> IO VkPipelineMultisampleStateCreateFlags
forall b.
Ptr b -> Int -> VkPipelineMultisampleStateCreateFlags -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr VkPipelineMultisampleStateCreateFlags
-> VkPipelineMultisampleStateCreateFlags -> IO ()
$cpoke :: Ptr VkPipelineMultisampleStateCreateFlags
-> VkPipelineMultisampleStateCreateFlags -> IO ()
peek :: Ptr VkPipelineMultisampleStateCreateFlags
-> IO VkPipelineMultisampleStateCreateFlags
$cpeek :: Ptr VkPipelineMultisampleStateCreateFlags
-> IO VkPipelineMultisampleStateCreateFlags
pokeByteOff :: forall b.
Ptr b -> Int -> VkPipelineMultisampleStateCreateFlags -> IO ()
$cpokeByteOff :: forall b.
Ptr b -> Int -> VkPipelineMultisampleStateCreateFlags -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO VkPipelineMultisampleStateCreateFlags
$cpeekByteOff :: forall b. Ptr b -> Int -> IO VkPipelineMultisampleStateCreateFlags
pokeElemOff :: Ptr VkPipelineMultisampleStateCreateFlags
-> Int -> VkPipelineMultisampleStateCreateFlags -> IO ()
$cpokeElemOff :: Ptr VkPipelineMultisampleStateCreateFlags
-> Int -> VkPipelineMultisampleStateCreateFlags -> IO ()
peekElemOff :: Ptr VkPipelineMultisampleStateCreateFlags
-> Int -> IO VkPipelineMultisampleStateCreateFlags
$cpeekElemOff :: Ptr VkPipelineMultisampleStateCreateFlags
-> Int -> IO VkPipelineMultisampleStateCreateFlags
alignment :: VkPipelineMultisampleStateCreateFlags -> Int
$calignment :: VkPipelineMultisampleStateCreateFlags -> Int
sizeOf :: VkPipelineMultisampleStateCreateFlags -> Int
$csizeOf :: VkPipelineMultisampleStateCreateFlags -> Int
Storable)

instance Show VkPipelineMultisampleStateCreateFlags where
    {-# INLINE showsPrec #-}
    showsPrec :: Int -> VkPipelineMultisampleStateCreateFlags -> ShowS
showsPrec = (Int -> VkFlags -> ShowS)
-> Int -> VkPipelineMultisampleStateCreateFlags -> ShowS
coerce (Int -> VkFlags -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec :: Int -> VkFlags -> ShowS)

instance Read VkPipelineMultisampleStateCreateFlags where
    {-# INLINE readsPrec #-}
    readsPrec :: Int -> ReadS VkPipelineMultisampleStateCreateFlags
readsPrec = (Int -> ReadS VkFlags)
-> Int -> ReadS VkPipelineMultisampleStateCreateFlags
coerce (Int -> ReadS VkFlags
forall a. Read a => Int -> ReadS a
readsPrec :: Int -> ReadS VkFlags)

newtype VkPipelineRasterizationConservativeStateCreateFlagsEXT = VkPipelineRasterizationConservativeStateCreateFlagsEXT VkFlags
                                                                 deriving (VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Bool
(VkPipelineRasterizationConservativeStateCreateFlagsEXT
 -> VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Bool)
-> (VkPipelineRasterizationConservativeStateCreateFlagsEXT
    -> VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Bool)
-> Eq VkPipelineRasterizationConservativeStateCreateFlagsEXT
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Bool
$c/= :: VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Bool
== :: VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Bool
$c== :: VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Bool
Eq, Eq VkPipelineRasterizationConservativeStateCreateFlagsEXT
Eq VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> (VkPipelineRasterizationConservativeStateCreateFlagsEXT
    -> VkPipelineRasterizationConservativeStateCreateFlagsEXT
    -> Ordering)
-> (VkPipelineRasterizationConservativeStateCreateFlagsEXT
    -> VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Bool)
-> (VkPipelineRasterizationConservativeStateCreateFlagsEXT
    -> VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Bool)
-> (VkPipelineRasterizationConservativeStateCreateFlagsEXT
    -> VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Bool)
-> (VkPipelineRasterizationConservativeStateCreateFlagsEXT
    -> VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Bool)
-> (VkPipelineRasterizationConservativeStateCreateFlagsEXT
    -> VkPipelineRasterizationConservativeStateCreateFlagsEXT
    -> VkPipelineRasterizationConservativeStateCreateFlagsEXT)
-> (VkPipelineRasterizationConservativeStateCreateFlagsEXT
    -> VkPipelineRasterizationConservativeStateCreateFlagsEXT
    -> VkPipelineRasterizationConservativeStateCreateFlagsEXT)
-> Ord VkPipelineRasterizationConservativeStateCreateFlagsEXT
VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Bool
VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> Ordering
VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> VkPipelineRasterizationConservativeStateCreateFlagsEXT
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> VkPipelineRasterizationConservativeStateCreateFlagsEXT
$cmin :: VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> VkPipelineRasterizationConservativeStateCreateFlagsEXT
max :: VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> VkPipelineRasterizationConservativeStateCreateFlagsEXT
$cmax :: VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> VkPipelineRasterizationConservativeStateCreateFlagsEXT
>= :: VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Bool
$c>= :: VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Bool
> :: VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Bool
$c> :: VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Bool
<= :: VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Bool
$c<= :: VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Bool
< :: VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Bool
$c< :: VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Bool
compare :: VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> Ordering
$ccompare :: VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> Ordering
Ord, Int -> VkPipelineRasterizationConservativeStateCreateFlagsEXT
VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Int
VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> [VkPipelineRasterizationConservativeStateCreateFlagsEXT]
VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> VkPipelineRasterizationConservativeStateCreateFlagsEXT
VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> [VkPipelineRasterizationConservativeStateCreateFlagsEXT]
VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> [VkPipelineRasterizationConservativeStateCreateFlagsEXT]
(VkPipelineRasterizationConservativeStateCreateFlagsEXT
 -> VkPipelineRasterizationConservativeStateCreateFlagsEXT)
-> (VkPipelineRasterizationConservativeStateCreateFlagsEXT
    -> VkPipelineRasterizationConservativeStateCreateFlagsEXT)
-> (Int -> VkPipelineRasterizationConservativeStateCreateFlagsEXT)
-> (VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Int)
-> (VkPipelineRasterizationConservativeStateCreateFlagsEXT
    -> [VkPipelineRasterizationConservativeStateCreateFlagsEXT])
-> (VkPipelineRasterizationConservativeStateCreateFlagsEXT
    -> VkPipelineRasterizationConservativeStateCreateFlagsEXT
    -> [VkPipelineRasterizationConservativeStateCreateFlagsEXT])
-> (VkPipelineRasterizationConservativeStateCreateFlagsEXT
    -> VkPipelineRasterizationConservativeStateCreateFlagsEXT
    -> [VkPipelineRasterizationConservativeStateCreateFlagsEXT])
-> (VkPipelineRasterizationConservativeStateCreateFlagsEXT
    -> VkPipelineRasterizationConservativeStateCreateFlagsEXT
    -> VkPipelineRasterizationConservativeStateCreateFlagsEXT
    -> [VkPipelineRasterizationConservativeStateCreateFlagsEXT])
-> Enum VkPipelineRasterizationConservativeStateCreateFlagsEXT
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> [VkPipelineRasterizationConservativeStateCreateFlagsEXT]
$cenumFromThenTo :: VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> [VkPipelineRasterizationConservativeStateCreateFlagsEXT]
enumFromTo :: VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> [VkPipelineRasterizationConservativeStateCreateFlagsEXT]
$cenumFromTo :: VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> [VkPipelineRasterizationConservativeStateCreateFlagsEXT]
enumFromThen :: VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> [VkPipelineRasterizationConservativeStateCreateFlagsEXT]
$cenumFromThen :: VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> [VkPipelineRasterizationConservativeStateCreateFlagsEXT]
enumFrom :: VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> [VkPipelineRasterizationConservativeStateCreateFlagsEXT]
$cenumFrom :: VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> [VkPipelineRasterizationConservativeStateCreateFlagsEXT]
fromEnum :: VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Int
$cfromEnum :: VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Int
toEnum :: Int -> VkPipelineRasterizationConservativeStateCreateFlagsEXT
$ctoEnum :: Int -> VkPipelineRasterizationConservativeStateCreateFlagsEXT
pred :: VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> VkPipelineRasterizationConservativeStateCreateFlagsEXT
$cpred :: VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> VkPipelineRasterizationConservativeStateCreateFlagsEXT
succ :: VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> VkPipelineRasterizationConservativeStateCreateFlagsEXT
$csucc :: VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> VkPipelineRasterizationConservativeStateCreateFlagsEXT
Enum, Eq VkPipelineRasterizationConservativeStateCreateFlagsEXT
VkPipelineRasterizationConservativeStateCreateFlagsEXT
Eq VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> (VkPipelineRasterizationConservativeStateCreateFlagsEXT
    -> VkPipelineRasterizationConservativeStateCreateFlagsEXT
    -> VkPipelineRasterizationConservativeStateCreateFlagsEXT)
-> (VkPipelineRasterizationConservativeStateCreateFlagsEXT
    -> VkPipelineRasterizationConservativeStateCreateFlagsEXT
    -> VkPipelineRasterizationConservativeStateCreateFlagsEXT)
-> (VkPipelineRasterizationConservativeStateCreateFlagsEXT
    -> VkPipelineRasterizationConservativeStateCreateFlagsEXT
    -> VkPipelineRasterizationConservativeStateCreateFlagsEXT)
-> (VkPipelineRasterizationConservativeStateCreateFlagsEXT
    -> VkPipelineRasterizationConservativeStateCreateFlagsEXT)
-> (VkPipelineRasterizationConservativeStateCreateFlagsEXT
    -> Int -> VkPipelineRasterizationConservativeStateCreateFlagsEXT)
-> (VkPipelineRasterizationConservativeStateCreateFlagsEXT
    -> Int -> VkPipelineRasterizationConservativeStateCreateFlagsEXT)
-> VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> (Int -> VkPipelineRasterizationConservativeStateCreateFlagsEXT)
-> (VkPipelineRasterizationConservativeStateCreateFlagsEXT
    -> Int -> VkPipelineRasterizationConservativeStateCreateFlagsEXT)
-> (VkPipelineRasterizationConservativeStateCreateFlagsEXT
    -> Int -> VkPipelineRasterizationConservativeStateCreateFlagsEXT)
-> (VkPipelineRasterizationConservativeStateCreateFlagsEXT
    -> Int -> VkPipelineRasterizationConservativeStateCreateFlagsEXT)
-> (VkPipelineRasterizationConservativeStateCreateFlagsEXT
    -> Int -> Bool)
-> (VkPipelineRasterizationConservativeStateCreateFlagsEXT
    -> Maybe Int)
-> (VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Int)
-> (VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Bool)
-> (VkPipelineRasterizationConservativeStateCreateFlagsEXT
    -> Int -> VkPipelineRasterizationConservativeStateCreateFlagsEXT)
-> (VkPipelineRasterizationConservativeStateCreateFlagsEXT
    -> Int -> VkPipelineRasterizationConservativeStateCreateFlagsEXT)
-> (VkPipelineRasterizationConservativeStateCreateFlagsEXT
    -> Int -> VkPipelineRasterizationConservativeStateCreateFlagsEXT)
-> (VkPipelineRasterizationConservativeStateCreateFlagsEXT
    -> Int -> VkPipelineRasterizationConservativeStateCreateFlagsEXT)
-> (VkPipelineRasterizationConservativeStateCreateFlagsEXT
    -> Int -> VkPipelineRasterizationConservativeStateCreateFlagsEXT)
-> (VkPipelineRasterizationConservativeStateCreateFlagsEXT
    -> Int -> VkPipelineRasterizationConservativeStateCreateFlagsEXT)
-> (VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Int)
-> Bits VkPipelineRasterizationConservativeStateCreateFlagsEXT
Int -> VkPipelineRasterizationConservativeStateCreateFlagsEXT
VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Bool
VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Int
VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Maybe Int
VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> VkPipelineRasterizationConservativeStateCreateFlagsEXT
VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> Int -> Bool
VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> Int -> VkPipelineRasterizationConservativeStateCreateFlagsEXT
VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> VkPipelineRasterizationConservativeStateCreateFlagsEXT
forall a.
Eq a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
popCount :: VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Int
$cpopCount :: VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Int
rotateR :: VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> Int -> VkPipelineRasterizationConservativeStateCreateFlagsEXT
$crotateR :: VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> Int -> VkPipelineRasterizationConservativeStateCreateFlagsEXT
rotateL :: VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> Int -> VkPipelineRasterizationConservativeStateCreateFlagsEXT
$crotateL :: VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> Int -> VkPipelineRasterizationConservativeStateCreateFlagsEXT
unsafeShiftR :: VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> Int -> VkPipelineRasterizationConservativeStateCreateFlagsEXT
$cunsafeShiftR :: VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> Int -> VkPipelineRasterizationConservativeStateCreateFlagsEXT
shiftR :: VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> Int -> VkPipelineRasterizationConservativeStateCreateFlagsEXT
$cshiftR :: VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> Int -> VkPipelineRasterizationConservativeStateCreateFlagsEXT
unsafeShiftL :: VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> Int -> VkPipelineRasterizationConservativeStateCreateFlagsEXT
$cunsafeShiftL :: VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> Int -> VkPipelineRasterizationConservativeStateCreateFlagsEXT
shiftL :: VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> Int -> VkPipelineRasterizationConservativeStateCreateFlagsEXT
$cshiftL :: VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> Int -> VkPipelineRasterizationConservativeStateCreateFlagsEXT
isSigned :: VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Bool
$cisSigned :: VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Bool
bitSize :: VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Int
$cbitSize :: VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Int
bitSizeMaybe :: VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Maybe Int
$cbitSizeMaybe :: VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Maybe Int
testBit :: VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> Int -> Bool
$ctestBit :: VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> Int -> Bool
complementBit :: VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> Int -> VkPipelineRasterizationConservativeStateCreateFlagsEXT
$ccomplementBit :: VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> Int -> VkPipelineRasterizationConservativeStateCreateFlagsEXT
clearBit :: VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> Int -> VkPipelineRasterizationConservativeStateCreateFlagsEXT
$cclearBit :: VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> Int -> VkPipelineRasterizationConservativeStateCreateFlagsEXT
setBit :: VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> Int -> VkPipelineRasterizationConservativeStateCreateFlagsEXT
$csetBit :: VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> Int -> VkPipelineRasterizationConservativeStateCreateFlagsEXT
bit :: Int -> VkPipelineRasterizationConservativeStateCreateFlagsEXT
$cbit :: Int -> VkPipelineRasterizationConservativeStateCreateFlagsEXT
zeroBits :: VkPipelineRasterizationConservativeStateCreateFlagsEXT
$czeroBits :: VkPipelineRasterizationConservativeStateCreateFlagsEXT
rotate :: VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> Int -> VkPipelineRasterizationConservativeStateCreateFlagsEXT
$crotate :: VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> Int -> VkPipelineRasterizationConservativeStateCreateFlagsEXT
shift :: VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> Int -> VkPipelineRasterizationConservativeStateCreateFlagsEXT
$cshift :: VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> Int -> VkPipelineRasterizationConservativeStateCreateFlagsEXT
complement :: VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> VkPipelineRasterizationConservativeStateCreateFlagsEXT
$ccomplement :: VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> VkPipelineRasterizationConservativeStateCreateFlagsEXT
xor :: VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> VkPipelineRasterizationConservativeStateCreateFlagsEXT
$cxor :: VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> VkPipelineRasterizationConservativeStateCreateFlagsEXT
.|. :: VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> VkPipelineRasterizationConservativeStateCreateFlagsEXT
$c.|. :: VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> VkPipelineRasterizationConservativeStateCreateFlagsEXT
.&. :: VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> VkPipelineRasterizationConservativeStateCreateFlagsEXT
$c.&. :: VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> VkPipelineRasterizationConservativeStateCreateFlagsEXT
Bits,
                                                                           Bits VkPipelineRasterizationConservativeStateCreateFlagsEXT
Bits VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> (VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Int)
-> (VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Int)
-> (VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Int)
-> FiniteBits
     VkPipelineRasterizationConservativeStateCreateFlagsEXT
VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Int
forall b.
Bits b -> (b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
countTrailingZeros :: VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Int
$ccountTrailingZeros :: VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Int
countLeadingZeros :: VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Int
$ccountLeadingZeros :: VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Int
finiteBitSize :: VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Int
$cfiniteBitSize :: VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Int
FiniteBits, Ptr VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> IO VkPipelineRasterizationConservativeStateCreateFlagsEXT
Ptr VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> Int -> IO VkPipelineRasterizationConservativeStateCreateFlagsEXT
Ptr VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> Int
-> VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> IO ()
Ptr VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> VkPipelineRasterizationConservativeStateCreateFlagsEXT -> IO ()
VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Int
(VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Int)
-> (VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Int)
-> (Ptr VkPipelineRasterizationConservativeStateCreateFlagsEXT
    -> Int
    -> IO VkPipelineRasterizationConservativeStateCreateFlagsEXT)
-> (Ptr VkPipelineRasterizationConservativeStateCreateFlagsEXT
    -> Int
    -> VkPipelineRasterizationConservativeStateCreateFlagsEXT
    -> IO ())
-> (forall b.
    Ptr b
    -> Int
    -> IO VkPipelineRasterizationConservativeStateCreateFlagsEXT)
-> (forall b.
    Ptr b
    -> Int
    -> VkPipelineRasterizationConservativeStateCreateFlagsEXT
    -> IO ())
-> (Ptr VkPipelineRasterizationConservativeStateCreateFlagsEXT
    -> IO VkPipelineRasterizationConservativeStateCreateFlagsEXT)
-> (Ptr VkPipelineRasterizationConservativeStateCreateFlagsEXT
    -> VkPipelineRasterizationConservativeStateCreateFlagsEXT -> IO ())
-> Storable VkPipelineRasterizationConservativeStateCreateFlagsEXT
forall b.
Ptr b
-> Int -> IO VkPipelineRasterizationConservativeStateCreateFlagsEXT
forall b.
Ptr b
-> Int
-> VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> VkPipelineRasterizationConservativeStateCreateFlagsEXT -> IO ()
$cpoke :: Ptr VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> VkPipelineRasterizationConservativeStateCreateFlagsEXT -> IO ()
peek :: Ptr VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> IO VkPipelineRasterizationConservativeStateCreateFlagsEXT
$cpeek :: Ptr VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> IO VkPipelineRasterizationConservativeStateCreateFlagsEXT
pokeByteOff :: forall b.
Ptr b
-> Int
-> VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> IO ()
$cpokeByteOff :: forall b.
Ptr b
-> Int
-> VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> IO ()
peekByteOff :: forall b.
Ptr b
-> Int -> IO VkPipelineRasterizationConservativeStateCreateFlagsEXT
$cpeekByteOff :: forall b.
Ptr b
-> Int -> IO VkPipelineRasterizationConservativeStateCreateFlagsEXT
pokeElemOff :: Ptr VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> Int
-> VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> IO ()
$cpokeElemOff :: Ptr VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> Int
-> VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> IO ()
peekElemOff :: Ptr VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> Int -> IO VkPipelineRasterizationConservativeStateCreateFlagsEXT
$cpeekElemOff :: Ptr VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> Int -> IO VkPipelineRasterizationConservativeStateCreateFlagsEXT
alignment :: VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Int
$calignment :: VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Int
sizeOf :: VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Int
$csizeOf :: VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Int
Storable)

instance Show
           VkPipelineRasterizationConservativeStateCreateFlagsEXT
         where
    {-# INLINE showsPrec #-}
    showsPrec :: Int
-> VkPipelineRasterizationConservativeStateCreateFlagsEXT -> ShowS
showsPrec = (Int -> VkFlags -> ShowS)
-> Int
-> VkPipelineRasterizationConservativeStateCreateFlagsEXT
-> ShowS
coerce (Int -> VkFlags -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec :: Int -> VkFlags -> ShowS)

instance Read
           VkPipelineRasterizationConservativeStateCreateFlagsEXT
         where
    {-# INLINE readsPrec #-}
    readsPrec :: Int -> ReadS VkPipelineRasterizationConservativeStateCreateFlagsEXT
readsPrec = (Int -> ReadS VkFlags)
-> Int
-> ReadS VkPipelineRasterizationConservativeStateCreateFlagsEXT
coerce (Int -> ReadS VkFlags
forall a. Read a => Int -> ReadS a
readsPrec :: Int -> ReadS VkFlags)

newtype VkPipelineRasterizationDepthClipStateCreateFlagsEXT = VkPipelineRasterizationDepthClipStateCreateFlagsEXT VkFlags
                                                              deriving (VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> VkPipelineRasterizationDepthClipStateCreateFlagsEXT -> Bool
(VkPipelineRasterizationDepthClipStateCreateFlagsEXT
 -> VkPipelineRasterizationDepthClipStateCreateFlagsEXT -> Bool)
-> (VkPipelineRasterizationDepthClipStateCreateFlagsEXT
    -> VkPipelineRasterizationDepthClipStateCreateFlagsEXT -> Bool)
-> Eq VkPipelineRasterizationDepthClipStateCreateFlagsEXT
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> VkPipelineRasterizationDepthClipStateCreateFlagsEXT -> Bool
$c/= :: VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> VkPipelineRasterizationDepthClipStateCreateFlagsEXT -> Bool
== :: VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> VkPipelineRasterizationDepthClipStateCreateFlagsEXT -> Bool
$c== :: VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> VkPipelineRasterizationDepthClipStateCreateFlagsEXT -> Bool
Eq, Eq VkPipelineRasterizationDepthClipStateCreateFlagsEXT
Eq VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> (VkPipelineRasterizationDepthClipStateCreateFlagsEXT
    -> VkPipelineRasterizationDepthClipStateCreateFlagsEXT -> Ordering)
-> (VkPipelineRasterizationDepthClipStateCreateFlagsEXT
    -> VkPipelineRasterizationDepthClipStateCreateFlagsEXT -> Bool)
-> (VkPipelineRasterizationDepthClipStateCreateFlagsEXT
    -> VkPipelineRasterizationDepthClipStateCreateFlagsEXT -> Bool)
-> (VkPipelineRasterizationDepthClipStateCreateFlagsEXT
    -> VkPipelineRasterizationDepthClipStateCreateFlagsEXT -> Bool)
-> (VkPipelineRasterizationDepthClipStateCreateFlagsEXT
    -> VkPipelineRasterizationDepthClipStateCreateFlagsEXT -> Bool)
-> (VkPipelineRasterizationDepthClipStateCreateFlagsEXT
    -> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
    -> VkPipelineRasterizationDepthClipStateCreateFlagsEXT)
-> (VkPipelineRasterizationDepthClipStateCreateFlagsEXT
    -> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
    -> VkPipelineRasterizationDepthClipStateCreateFlagsEXT)
-> Ord VkPipelineRasterizationDepthClipStateCreateFlagsEXT
VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> VkPipelineRasterizationDepthClipStateCreateFlagsEXT -> Bool
VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> VkPipelineRasterizationDepthClipStateCreateFlagsEXT -> Ordering
VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
$cmin :: VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
max :: VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
$cmax :: VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
>= :: VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> VkPipelineRasterizationDepthClipStateCreateFlagsEXT -> Bool
$c>= :: VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> VkPipelineRasterizationDepthClipStateCreateFlagsEXT -> Bool
> :: VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> VkPipelineRasterizationDepthClipStateCreateFlagsEXT -> Bool
$c> :: VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> VkPipelineRasterizationDepthClipStateCreateFlagsEXT -> Bool
<= :: VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> VkPipelineRasterizationDepthClipStateCreateFlagsEXT -> Bool
$c<= :: VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> VkPipelineRasterizationDepthClipStateCreateFlagsEXT -> Bool
< :: VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> VkPipelineRasterizationDepthClipStateCreateFlagsEXT -> Bool
$c< :: VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> VkPipelineRasterizationDepthClipStateCreateFlagsEXT -> Bool
compare :: VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> VkPipelineRasterizationDepthClipStateCreateFlagsEXT -> Ordering
$ccompare :: VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> VkPipelineRasterizationDepthClipStateCreateFlagsEXT -> Ordering
Ord, Int -> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
VkPipelineRasterizationDepthClipStateCreateFlagsEXT -> Int
VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> [VkPipelineRasterizationDepthClipStateCreateFlagsEXT]
VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> [VkPipelineRasterizationDepthClipStateCreateFlagsEXT]
VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> [VkPipelineRasterizationDepthClipStateCreateFlagsEXT]
(VkPipelineRasterizationDepthClipStateCreateFlagsEXT
 -> VkPipelineRasterizationDepthClipStateCreateFlagsEXT)
-> (VkPipelineRasterizationDepthClipStateCreateFlagsEXT
    -> VkPipelineRasterizationDepthClipStateCreateFlagsEXT)
-> (Int -> VkPipelineRasterizationDepthClipStateCreateFlagsEXT)
-> (VkPipelineRasterizationDepthClipStateCreateFlagsEXT -> Int)
-> (VkPipelineRasterizationDepthClipStateCreateFlagsEXT
    -> [VkPipelineRasterizationDepthClipStateCreateFlagsEXT])
-> (VkPipelineRasterizationDepthClipStateCreateFlagsEXT
    -> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
    -> [VkPipelineRasterizationDepthClipStateCreateFlagsEXT])
-> (VkPipelineRasterizationDepthClipStateCreateFlagsEXT
    -> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
    -> [VkPipelineRasterizationDepthClipStateCreateFlagsEXT])
-> (VkPipelineRasterizationDepthClipStateCreateFlagsEXT
    -> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
    -> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
    -> [VkPipelineRasterizationDepthClipStateCreateFlagsEXT])
-> Enum VkPipelineRasterizationDepthClipStateCreateFlagsEXT
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> [VkPipelineRasterizationDepthClipStateCreateFlagsEXT]
$cenumFromThenTo :: VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> [VkPipelineRasterizationDepthClipStateCreateFlagsEXT]
enumFromTo :: VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> [VkPipelineRasterizationDepthClipStateCreateFlagsEXT]
$cenumFromTo :: VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> [VkPipelineRasterizationDepthClipStateCreateFlagsEXT]
enumFromThen :: VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> [VkPipelineRasterizationDepthClipStateCreateFlagsEXT]
$cenumFromThen :: VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> [VkPipelineRasterizationDepthClipStateCreateFlagsEXT]
enumFrom :: VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> [VkPipelineRasterizationDepthClipStateCreateFlagsEXT]
$cenumFrom :: VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> [VkPipelineRasterizationDepthClipStateCreateFlagsEXT]
fromEnum :: VkPipelineRasterizationDepthClipStateCreateFlagsEXT -> Int
$cfromEnum :: VkPipelineRasterizationDepthClipStateCreateFlagsEXT -> Int
toEnum :: Int -> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
$ctoEnum :: Int -> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
pred :: VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
$cpred :: VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
succ :: VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
$csucc :: VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
Enum, Eq VkPipelineRasterizationDepthClipStateCreateFlagsEXT
VkPipelineRasterizationDepthClipStateCreateFlagsEXT
Eq VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> (VkPipelineRasterizationDepthClipStateCreateFlagsEXT
    -> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
    -> VkPipelineRasterizationDepthClipStateCreateFlagsEXT)
-> (VkPipelineRasterizationDepthClipStateCreateFlagsEXT
    -> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
    -> VkPipelineRasterizationDepthClipStateCreateFlagsEXT)
-> (VkPipelineRasterizationDepthClipStateCreateFlagsEXT
    -> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
    -> VkPipelineRasterizationDepthClipStateCreateFlagsEXT)
-> (VkPipelineRasterizationDepthClipStateCreateFlagsEXT
    -> VkPipelineRasterizationDepthClipStateCreateFlagsEXT)
-> (VkPipelineRasterizationDepthClipStateCreateFlagsEXT
    -> Int -> VkPipelineRasterizationDepthClipStateCreateFlagsEXT)
-> (VkPipelineRasterizationDepthClipStateCreateFlagsEXT
    -> Int -> VkPipelineRasterizationDepthClipStateCreateFlagsEXT)
-> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> (Int -> VkPipelineRasterizationDepthClipStateCreateFlagsEXT)
-> (VkPipelineRasterizationDepthClipStateCreateFlagsEXT
    -> Int -> VkPipelineRasterizationDepthClipStateCreateFlagsEXT)
-> (VkPipelineRasterizationDepthClipStateCreateFlagsEXT
    -> Int -> VkPipelineRasterizationDepthClipStateCreateFlagsEXT)
-> (VkPipelineRasterizationDepthClipStateCreateFlagsEXT
    -> Int -> VkPipelineRasterizationDepthClipStateCreateFlagsEXT)
-> (VkPipelineRasterizationDepthClipStateCreateFlagsEXT
    -> Int -> Bool)
-> (VkPipelineRasterizationDepthClipStateCreateFlagsEXT
    -> Maybe Int)
-> (VkPipelineRasterizationDepthClipStateCreateFlagsEXT -> Int)
-> (VkPipelineRasterizationDepthClipStateCreateFlagsEXT -> Bool)
-> (VkPipelineRasterizationDepthClipStateCreateFlagsEXT
    -> Int -> VkPipelineRasterizationDepthClipStateCreateFlagsEXT)
-> (VkPipelineRasterizationDepthClipStateCreateFlagsEXT
    -> Int -> VkPipelineRasterizationDepthClipStateCreateFlagsEXT)
-> (VkPipelineRasterizationDepthClipStateCreateFlagsEXT
    -> Int -> VkPipelineRasterizationDepthClipStateCreateFlagsEXT)
-> (VkPipelineRasterizationDepthClipStateCreateFlagsEXT
    -> Int -> VkPipelineRasterizationDepthClipStateCreateFlagsEXT)
-> (VkPipelineRasterizationDepthClipStateCreateFlagsEXT
    -> Int -> VkPipelineRasterizationDepthClipStateCreateFlagsEXT)
-> (VkPipelineRasterizationDepthClipStateCreateFlagsEXT
    -> Int -> VkPipelineRasterizationDepthClipStateCreateFlagsEXT)
-> (VkPipelineRasterizationDepthClipStateCreateFlagsEXT -> Int)
-> Bits VkPipelineRasterizationDepthClipStateCreateFlagsEXT
Int -> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
VkPipelineRasterizationDepthClipStateCreateFlagsEXT -> Bool
VkPipelineRasterizationDepthClipStateCreateFlagsEXT -> Int
VkPipelineRasterizationDepthClipStateCreateFlagsEXT -> Maybe Int
VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
VkPipelineRasterizationDepthClipStateCreateFlagsEXT -> Int -> Bool
VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> Int -> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
forall a.
Eq a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
popCount :: VkPipelineRasterizationDepthClipStateCreateFlagsEXT -> Int
$cpopCount :: VkPipelineRasterizationDepthClipStateCreateFlagsEXT -> Int
rotateR :: VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> Int -> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
$crotateR :: VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> Int -> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
rotateL :: VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> Int -> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
$crotateL :: VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> Int -> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
unsafeShiftR :: VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> Int -> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
$cunsafeShiftR :: VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> Int -> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
shiftR :: VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> Int -> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
$cshiftR :: VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> Int -> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
unsafeShiftL :: VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> Int -> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
$cunsafeShiftL :: VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> Int -> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
shiftL :: VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> Int -> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
$cshiftL :: VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> Int -> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
isSigned :: VkPipelineRasterizationDepthClipStateCreateFlagsEXT -> Bool
$cisSigned :: VkPipelineRasterizationDepthClipStateCreateFlagsEXT -> Bool
bitSize :: VkPipelineRasterizationDepthClipStateCreateFlagsEXT -> Int
$cbitSize :: VkPipelineRasterizationDepthClipStateCreateFlagsEXT -> Int
bitSizeMaybe :: VkPipelineRasterizationDepthClipStateCreateFlagsEXT -> Maybe Int
$cbitSizeMaybe :: VkPipelineRasterizationDepthClipStateCreateFlagsEXT -> Maybe Int
testBit :: VkPipelineRasterizationDepthClipStateCreateFlagsEXT -> Int -> Bool
$ctestBit :: VkPipelineRasterizationDepthClipStateCreateFlagsEXT -> Int -> Bool
complementBit :: VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> Int -> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
$ccomplementBit :: VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> Int -> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
clearBit :: VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> Int -> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
$cclearBit :: VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> Int -> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
setBit :: VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> Int -> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
$csetBit :: VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> Int -> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
bit :: Int -> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
$cbit :: Int -> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
zeroBits :: VkPipelineRasterizationDepthClipStateCreateFlagsEXT
$czeroBits :: VkPipelineRasterizationDepthClipStateCreateFlagsEXT
rotate :: VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> Int -> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
$crotate :: VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> Int -> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
shift :: VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> Int -> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
$cshift :: VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> Int -> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
complement :: VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
$ccomplement :: VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
xor :: VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
$cxor :: VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
.|. :: VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
$c.|. :: VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
.&. :: VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
$c.&. :: VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
Bits,
                                                                        Bits VkPipelineRasterizationDepthClipStateCreateFlagsEXT
Bits VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> (VkPipelineRasterizationDepthClipStateCreateFlagsEXT -> Int)
-> (VkPipelineRasterizationDepthClipStateCreateFlagsEXT -> Int)
-> (VkPipelineRasterizationDepthClipStateCreateFlagsEXT -> Int)
-> FiniteBits VkPipelineRasterizationDepthClipStateCreateFlagsEXT
VkPipelineRasterizationDepthClipStateCreateFlagsEXT -> Int
forall b.
Bits b -> (b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
countTrailingZeros :: VkPipelineRasterizationDepthClipStateCreateFlagsEXT -> Int
$ccountTrailingZeros :: VkPipelineRasterizationDepthClipStateCreateFlagsEXT -> Int
countLeadingZeros :: VkPipelineRasterizationDepthClipStateCreateFlagsEXT -> Int
$ccountLeadingZeros :: VkPipelineRasterizationDepthClipStateCreateFlagsEXT -> Int
finiteBitSize :: VkPipelineRasterizationDepthClipStateCreateFlagsEXT -> Int
$cfiniteBitSize :: VkPipelineRasterizationDepthClipStateCreateFlagsEXT -> Int
FiniteBits, Ptr VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> IO VkPipelineRasterizationDepthClipStateCreateFlagsEXT
Ptr VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> Int -> IO VkPipelineRasterizationDepthClipStateCreateFlagsEXT
Ptr VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> Int
-> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> IO ()
Ptr VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> VkPipelineRasterizationDepthClipStateCreateFlagsEXT -> IO ()
VkPipelineRasterizationDepthClipStateCreateFlagsEXT -> Int
(VkPipelineRasterizationDepthClipStateCreateFlagsEXT -> Int)
-> (VkPipelineRasterizationDepthClipStateCreateFlagsEXT -> Int)
-> (Ptr VkPipelineRasterizationDepthClipStateCreateFlagsEXT
    -> Int -> IO VkPipelineRasterizationDepthClipStateCreateFlagsEXT)
-> (Ptr VkPipelineRasterizationDepthClipStateCreateFlagsEXT
    -> Int
    -> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
    -> IO ())
-> (forall b.
    Ptr b
    -> Int -> IO VkPipelineRasterizationDepthClipStateCreateFlagsEXT)
-> (forall b.
    Ptr b
    -> Int
    -> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
    -> IO ())
-> (Ptr VkPipelineRasterizationDepthClipStateCreateFlagsEXT
    -> IO VkPipelineRasterizationDepthClipStateCreateFlagsEXT)
-> (Ptr VkPipelineRasterizationDepthClipStateCreateFlagsEXT
    -> VkPipelineRasterizationDepthClipStateCreateFlagsEXT -> IO ())
-> Storable VkPipelineRasterizationDepthClipStateCreateFlagsEXT
forall b.
Ptr b
-> Int -> IO VkPipelineRasterizationDepthClipStateCreateFlagsEXT
forall b.
Ptr b
-> Int
-> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> VkPipelineRasterizationDepthClipStateCreateFlagsEXT -> IO ()
$cpoke :: Ptr VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> VkPipelineRasterizationDepthClipStateCreateFlagsEXT -> IO ()
peek :: Ptr VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> IO VkPipelineRasterizationDepthClipStateCreateFlagsEXT
$cpeek :: Ptr VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> IO VkPipelineRasterizationDepthClipStateCreateFlagsEXT
pokeByteOff :: forall b.
Ptr b
-> Int
-> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> IO ()
$cpokeByteOff :: forall b.
Ptr b
-> Int
-> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> IO ()
peekByteOff :: forall b.
Ptr b
-> Int -> IO VkPipelineRasterizationDepthClipStateCreateFlagsEXT
$cpeekByteOff :: forall b.
Ptr b
-> Int -> IO VkPipelineRasterizationDepthClipStateCreateFlagsEXT
pokeElemOff :: Ptr VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> Int
-> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> IO ()
$cpokeElemOff :: Ptr VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> Int
-> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> IO ()
peekElemOff :: Ptr VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> Int -> IO VkPipelineRasterizationDepthClipStateCreateFlagsEXT
$cpeekElemOff :: Ptr VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> Int -> IO VkPipelineRasterizationDepthClipStateCreateFlagsEXT
alignment :: VkPipelineRasterizationDepthClipStateCreateFlagsEXT -> Int
$calignment :: VkPipelineRasterizationDepthClipStateCreateFlagsEXT -> Int
sizeOf :: VkPipelineRasterizationDepthClipStateCreateFlagsEXT -> Int
$csizeOf :: VkPipelineRasterizationDepthClipStateCreateFlagsEXT -> Int
Storable)

instance Show VkPipelineRasterizationDepthClipStateCreateFlagsEXT
         where
    {-# INLINE showsPrec #-}
    showsPrec :: Int -> VkPipelineRasterizationDepthClipStateCreateFlagsEXT -> ShowS
showsPrec = (Int -> VkFlags -> ShowS)
-> Int
-> VkPipelineRasterizationDepthClipStateCreateFlagsEXT
-> ShowS
coerce (Int -> VkFlags -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec :: Int -> VkFlags -> ShowS)

instance Read VkPipelineRasterizationDepthClipStateCreateFlagsEXT
         where
    {-# INLINE readsPrec #-}
    readsPrec :: Int -> ReadS VkPipelineRasterizationDepthClipStateCreateFlagsEXT
readsPrec = (Int -> ReadS VkFlags)
-> Int -> ReadS VkPipelineRasterizationDepthClipStateCreateFlagsEXT
coerce (Int -> ReadS VkFlags
forall a. Read a => Int -> ReadS a
readsPrec :: Int -> ReadS VkFlags)

newtype VkPipelineRasterizationStateCreateFlags = VkPipelineRasterizationStateCreateFlags VkFlags
                                                  deriving (VkPipelineRasterizationStateCreateFlags
-> VkPipelineRasterizationStateCreateFlags -> Bool
(VkPipelineRasterizationStateCreateFlags
 -> VkPipelineRasterizationStateCreateFlags -> Bool)
-> (VkPipelineRasterizationStateCreateFlags
    -> VkPipelineRasterizationStateCreateFlags -> Bool)
-> Eq VkPipelineRasterizationStateCreateFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VkPipelineRasterizationStateCreateFlags
-> VkPipelineRasterizationStateCreateFlags -> Bool
$c/= :: VkPipelineRasterizationStateCreateFlags
-> VkPipelineRasterizationStateCreateFlags -> Bool
== :: VkPipelineRasterizationStateCreateFlags
-> VkPipelineRasterizationStateCreateFlags -> Bool
$c== :: VkPipelineRasterizationStateCreateFlags
-> VkPipelineRasterizationStateCreateFlags -> Bool
Eq, Eq VkPipelineRasterizationStateCreateFlags
Eq VkPipelineRasterizationStateCreateFlags
-> (VkPipelineRasterizationStateCreateFlags
    -> VkPipelineRasterizationStateCreateFlags -> Ordering)
-> (VkPipelineRasterizationStateCreateFlags
    -> VkPipelineRasterizationStateCreateFlags -> Bool)
-> (VkPipelineRasterizationStateCreateFlags
    -> VkPipelineRasterizationStateCreateFlags -> Bool)
-> (VkPipelineRasterizationStateCreateFlags
    -> VkPipelineRasterizationStateCreateFlags -> Bool)
-> (VkPipelineRasterizationStateCreateFlags
    -> VkPipelineRasterizationStateCreateFlags -> Bool)
-> (VkPipelineRasterizationStateCreateFlags
    -> VkPipelineRasterizationStateCreateFlags
    -> VkPipelineRasterizationStateCreateFlags)
-> (VkPipelineRasterizationStateCreateFlags
    -> VkPipelineRasterizationStateCreateFlags
    -> VkPipelineRasterizationStateCreateFlags)
-> Ord VkPipelineRasterizationStateCreateFlags
VkPipelineRasterizationStateCreateFlags
-> VkPipelineRasterizationStateCreateFlags -> Bool
VkPipelineRasterizationStateCreateFlags
-> VkPipelineRasterizationStateCreateFlags -> Ordering
VkPipelineRasterizationStateCreateFlags
-> VkPipelineRasterizationStateCreateFlags
-> VkPipelineRasterizationStateCreateFlags
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: VkPipelineRasterizationStateCreateFlags
-> VkPipelineRasterizationStateCreateFlags
-> VkPipelineRasterizationStateCreateFlags
$cmin :: VkPipelineRasterizationStateCreateFlags
-> VkPipelineRasterizationStateCreateFlags
-> VkPipelineRasterizationStateCreateFlags
max :: VkPipelineRasterizationStateCreateFlags
-> VkPipelineRasterizationStateCreateFlags
-> VkPipelineRasterizationStateCreateFlags
$cmax :: VkPipelineRasterizationStateCreateFlags
-> VkPipelineRasterizationStateCreateFlags
-> VkPipelineRasterizationStateCreateFlags
>= :: VkPipelineRasterizationStateCreateFlags
-> VkPipelineRasterizationStateCreateFlags -> Bool
$c>= :: VkPipelineRasterizationStateCreateFlags
-> VkPipelineRasterizationStateCreateFlags -> Bool
> :: VkPipelineRasterizationStateCreateFlags
-> VkPipelineRasterizationStateCreateFlags -> Bool
$c> :: VkPipelineRasterizationStateCreateFlags
-> VkPipelineRasterizationStateCreateFlags -> Bool
<= :: VkPipelineRasterizationStateCreateFlags
-> VkPipelineRasterizationStateCreateFlags -> Bool
$c<= :: VkPipelineRasterizationStateCreateFlags
-> VkPipelineRasterizationStateCreateFlags -> Bool
< :: VkPipelineRasterizationStateCreateFlags
-> VkPipelineRasterizationStateCreateFlags -> Bool
$c< :: VkPipelineRasterizationStateCreateFlags
-> VkPipelineRasterizationStateCreateFlags -> Bool
compare :: VkPipelineRasterizationStateCreateFlags
-> VkPipelineRasterizationStateCreateFlags -> Ordering
$ccompare :: VkPipelineRasterizationStateCreateFlags
-> VkPipelineRasterizationStateCreateFlags -> Ordering
Ord, Int -> VkPipelineRasterizationStateCreateFlags
VkPipelineRasterizationStateCreateFlags -> Int
VkPipelineRasterizationStateCreateFlags
-> [VkPipelineRasterizationStateCreateFlags]
VkPipelineRasterizationStateCreateFlags
-> VkPipelineRasterizationStateCreateFlags
VkPipelineRasterizationStateCreateFlags
-> VkPipelineRasterizationStateCreateFlags
-> [VkPipelineRasterizationStateCreateFlags]
VkPipelineRasterizationStateCreateFlags
-> VkPipelineRasterizationStateCreateFlags
-> VkPipelineRasterizationStateCreateFlags
-> [VkPipelineRasterizationStateCreateFlags]
(VkPipelineRasterizationStateCreateFlags
 -> VkPipelineRasterizationStateCreateFlags)
-> (VkPipelineRasterizationStateCreateFlags
    -> VkPipelineRasterizationStateCreateFlags)
-> (Int -> VkPipelineRasterizationStateCreateFlags)
-> (VkPipelineRasterizationStateCreateFlags -> Int)
-> (VkPipelineRasterizationStateCreateFlags
    -> [VkPipelineRasterizationStateCreateFlags])
-> (VkPipelineRasterizationStateCreateFlags
    -> VkPipelineRasterizationStateCreateFlags
    -> [VkPipelineRasterizationStateCreateFlags])
-> (VkPipelineRasterizationStateCreateFlags
    -> VkPipelineRasterizationStateCreateFlags
    -> [VkPipelineRasterizationStateCreateFlags])
-> (VkPipelineRasterizationStateCreateFlags
    -> VkPipelineRasterizationStateCreateFlags
    -> VkPipelineRasterizationStateCreateFlags
    -> [VkPipelineRasterizationStateCreateFlags])
-> Enum VkPipelineRasterizationStateCreateFlags
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: VkPipelineRasterizationStateCreateFlags
-> VkPipelineRasterizationStateCreateFlags
-> VkPipelineRasterizationStateCreateFlags
-> [VkPipelineRasterizationStateCreateFlags]
$cenumFromThenTo :: VkPipelineRasterizationStateCreateFlags
-> VkPipelineRasterizationStateCreateFlags
-> VkPipelineRasterizationStateCreateFlags
-> [VkPipelineRasterizationStateCreateFlags]
enumFromTo :: VkPipelineRasterizationStateCreateFlags
-> VkPipelineRasterizationStateCreateFlags
-> [VkPipelineRasterizationStateCreateFlags]
$cenumFromTo :: VkPipelineRasterizationStateCreateFlags
-> VkPipelineRasterizationStateCreateFlags
-> [VkPipelineRasterizationStateCreateFlags]
enumFromThen :: VkPipelineRasterizationStateCreateFlags
-> VkPipelineRasterizationStateCreateFlags
-> [VkPipelineRasterizationStateCreateFlags]
$cenumFromThen :: VkPipelineRasterizationStateCreateFlags
-> VkPipelineRasterizationStateCreateFlags
-> [VkPipelineRasterizationStateCreateFlags]
enumFrom :: VkPipelineRasterizationStateCreateFlags
-> [VkPipelineRasterizationStateCreateFlags]
$cenumFrom :: VkPipelineRasterizationStateCreateFlags
-> [VkPipelineRasterizationStateCreateFlags]
fromEnum :: VkPipelineRasterizationStateCreateFlags -> Int
$cfromEnum :: VkPipelineRasterizationStateCreateFlags -> Int
toEnum :: Int -> VkPipelineRasterizationStateCreateFlags
$ctoEnum :: Int -> VkPipelineRasterizationStateCreateFlags
pred :: VkPipelineRasterizationStateCreateFlags
-> VkPipelineRasterizationStateCreateFlags
$cpred :: VkPipelineRasterizationStateCreateFlags
-> VkPipelineRasterizationStateCreateFlags
succ :: VkPipelineRasterizationStateCreateFlags
-> VkPipelineRasterizationStateCreateFlags
$csucc :: VkPipelineRasterizationStateCreateFlags
-> VkPipelineRasterizationStateCreateFlags
Enum, Eq VkPipelineRasterizationStateCreateFlags
VkPipelineRasterizationStateCreateFlags
Eq VkPipelineRasterizationStateCreateFlags
-> (VkPipelineRasterizationStateCreateFlags
    -> VkPipelineRasterizationStateCreateFlags
    -> VkPipelineRasterizationStateCreateFlags)
-> (VkPipelineRasterizationStateCreateFlags
    -> VkPipelineRasterizationStateCreateFlags
    -> VkPipelineRasterizationStateCreateFlags)
-> (VkPipelineRasterizationStateCreateFlags
    -> VkPipelineRasterizationStateCreateFlags
    -> VkPipelineRasterizationStateCreateFlags)
-> (VkPipelineRasterizationStateCreateFlags
    -> VkPipelineRasterizationStateCreateFlags)
-> (VkPipelineRasterizationStateCreateFlags
    -> Int -> VkPipelineRasterizationStateCreateFlags)
-> (VkPipelineRasterizationStateCreateFlags
    -> Int -> VkPipelineRasterizationStateCreateFlags)
-> VkPipelineRasterizationStateCreateFlags
-> (Int -> VkPipelineRasterizationStateCreateFlags)
-> (VkPipelineRasterizationStateCreateFlags
    -> Int -> VkPipelineRasterizationStateCreateFlags)
-> (VkPipelineRasterizationStateCreateFlags
    -> Int -> VkPipelineRasterizationStateCreateFlags)
-> (VkPipelineRasterizationStateCreateFlags
    -> Int -> VkPipelineRasterizationStateCreateFlags)
-> (VkPipelineRasterizationStateCreateFlags -> Int -> Bool)
-> (VkPipelineRasterizationStateCreateFlags -> Maybe Int)
-> (VkPipelineRasterizationStateCreateFlags -> Int)
-> (VkPipelineRasterizationStateCreateFlags -> Bool)
-> (VkPipelineRasterizationStateCreateFlags
    -> Int -> VkPipelineRasterizationStateCreateFlags)
-> (VkPipelineRasterizationStateCreateFlags
    -> Int -> VkPipelineRasterizationStateCreateFlags)
-> (VkPipelineRasterizationStateCreateFlags
    -> Int -> VkPipelineRasterizationStateCreateFlags)
-> (VkPipelineRasterizationStateCreateFlags
    -> Int -> VkPipelineRasterizationStateCreateFlags)
-> (VkPipelineRasterizationStateCreateFlags
    -> Int -> VkPipelineRasterizationStateCreateFlags)
-> (VkPipelineRasterizationStateCreateFlags
    -> Int -> VkPipelineRasterizationStateCreateFlags)
-> (VkPipelineRasterizationStateCreateFlags -> Int)
-> Bits VkPipelineRasterizationStateCreateFlags
Int -> VkPipelineRasterizationStateCreateFlags
VkPipelineRasterizationStateCreateFlags -> Bool
VkPipelineRasterizationStateCreateFlags -> Int
VkPipelineRasterizationStateCreateFlags -> Maybe Int
VkPipelineRasterizationStateCreateFlags
-> VkPipelineRasterizationStateCreateFlags
VkPipelineRasterizationStateCreateFlags -> Int -> Bool
VkPipelineRasterizationStateCreateFlags
-> Int -> VkPipelineRasterizationStateCreateFlags
VkPipelineRasterizationStateCreateFlags
-> VkPipelineRasterizationStateCreateFlags
-> VkPipelineRasterizationStateCreateFlags
forall a.
Eq a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
popCount :: VkPipelineRasterizationStateCreateFlags -> Int
$cpopCount :: VkPipelineRasterizationStateCreateFlags -> Int
rotateR :: VkPipelineRasterizationStateCreateFlags
-> Int -> VkPipelineRasterizationStateCreateFlags
$crotateR :: VkPipelineRasterizationStateCreateFlags
-> Int -> VkPipelineRasterizationStateCreateFlags
rotateL :: VkPipelineRasterizationStateCreateFlags
-> Int -> VkPipelineRasterizationStateCreateFlags
$crotateL :: VkPipelineRasterizationStateCreateFlags
-> Int -> VkPipelineRasterizationStateCreateFlags
unsafeShiftR :: VkPipelineRasterizationStateCreateFlags
-> Int -> VkPipelineRasterizationStateCreateFlags
$cunsafeShiftR :: VkPipelineRasterizationStateCreateFlags
-> Int -> VkPipelineRasterizationStateCreateFlags
shiftR :: VkPipelineRasterizationStateCreateFlags
-> Int -> VkPipelineRasterizationStateCreateFlags
$cshiftR :: VkPipelineRasterizationStateCreateFlags
-> Int -> VkPipelineRasterizationStateCreateFlags
unsafeShiftL :: VkPipelineRasterizationStateCreateFlags
-> Int -> VkPipelineRasterizationStateCreateFlags
$cunsafeShiftL :: VkPipelineRasterizationStateCreateFlags
-> Int -> VkPipelineRasterizationStateCreateFlags
shiftL :: VkPipelineRasterizationStateCreateFlags
-> Int -> VkPipelineRasterizationStateCreateFlags
$cshiftL :: VkPipelineRasterizationStateCreateFlags
-> Int -> VkPipelineRasterizationStateCreateFlags
isSigned :: VkPipelineRasterizationStateCreateFlags -> Bool
$cisSigned :: VkPipelineRasterizationStateCreateFlags -> Bool
bitSize :: VkPipelineRasterizationStateCreateFlags -> Int
$cbitSize :: VkPipelineRasterizationStateCreateFlags -> Int
bitSizeMaybe :: VkPipelineRasterizationStateCreateFlags -> Maybe Int
$cbitSizeMaybe :: VkPipelineRasterizationStateCreateFlags -> Maybe Int
testBit :: VkPipelineRasterizationStateCreateFlags -> Int -> Bool
$ctestBit :: VkPipelineRasterizationStateCreateFlags -> Int -> Bool
complementBit :: VkPipelineRasterizationStateCreateFlags
-> Int -> VkPipelineRasterizationStateCreateFlags
$ccomplementBit :: VkPipelineRasterizationStateCreateFlags
-> Int -> VkPipelineRasterizationStateCreateFlags
clearBit :: VkPipelineRasterizationStateCreateFlags
-> Int -> VkPipelineRasterizationStateCreateFlags
$cclearBit :: VkPipelineRasterizationStateCreateFlags
-> Int -> VkPipelineRasterizationStateCreateFlags
setBit :: VkPipelineRasterizationStateCreateFlags
-> Int -> VkPipelineRasterizationStateCreateFlags
$csetBit :: VkPipelineRasterizationStateCreateFlags
-> Int -> VkPipelineRasterizationStateCreateFlags
bit :: Int -> VkPipelineRasterizationStateCreateFlags
$cbit :: Int -> VkPipelineRasterizationStateCreateFlags
zeroBits :: VkPipelineRasterizationStateCreateFlags
$czeroBits :: VkPipelineRasterizationStateCreateFlags
rotate :: VkPipelineRasterizationStateCreateFlags
-> Int -> VkPipelineRasterizationStateCreateFlags
$crotate :: VkPipelineRasterizationStateCreateFlags
-> Int -> VkPipelineRasterizationStateCreateFlags
shift :: VkPipelineRasterizationStateCreateFlags
-> Int -> VkPipelineRasterizationStateCreateFlags
$cshift :: VkPipelineRasterizationStateCreateFlags
-> Int -> VkPipelineRasterizationStateCreateFlags
complement :: VkPipelineRasterizationStateCreateFlags
-> VkPipelineRasterizationStateCreateFlags
$ccomplement :: VkPipelineRasterizationStateCreateFlags
-> VkPipelineRasterizationStateCreateFlags
xor :: VkPipelineRasterizationStateCreateFlags
-> VkPipelineRasterizationStateCreateFlags
-> VkPipelineRasterizationStateCreateFlags
$cxor :: VkPipelineRasterizationStateCreateFlags
-> VkPipelineRasterizationStateCreateFlags
-> VkPipelineRasterizationStateCreateFlags
.|. :: VkPipelineRasterizationStateCreateFlags
-> VkPipelineRasterizationStateCreateFlags
-> VkPipelineRasterizationStateCreateFlags
$c.|. :: VkPipelineRasterizationStateCreateFlags
-> VkPipelineRasterizationStateCreateFlags
-> VkPipelineRasterizationStateCreateFlags
.&. :: VkPipelineRasterizationStateCreateFlags
-> VkPipelineRasterizationStateCreateFlags
-> VkPipelineRasterizationStateCreateFlags
$c.&. :: VkPipelineRasterizationStateCreateFlags
-> VkPipelineRasterizationStateCreateFlags
-> VkPipelineRasterizationStateCreateFlags
Bits, Bits VkPipelineRasterizationStateCreateFlags
Bits VkPipelineRasterizationStateCreateFlags
-> (VkPipelineRasterizationStateCreateFlags -> Int)
-> (VkPipelineRasterizationStateCreateFlags -> Int)
-> (VkPipelineRasterizationStateCreateFlags -> Int)
-> FiniteBits VkPipelineRasterizationStateCreateFlags
VkPipelineRasterizationStateCreateFlags -> Int
forall b.
Bits b -> (b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
countTrailingZeros :: VkPipelineRasterizationStateCreateFlags -> Int
$ccountTrailingZeros :: VkPipelineRasterizationStateCreateFlags -> Int
countLeadingZeros :: VkPipelineRasterizationStateCreateFlags -> Int
$ccountLeadingZeros :: VkPipelineRasterizationStateCreateFlags -> Int
finiteBitSize :: VkPipelineRasterizationStateCreateFlags -> Int
$cfiniteBitSize :: VkPipelineRasterizationStateCreateFlags -> Int
FiniteBits,
                                                            Ptr VkPipelineRasterizationStateCreateFlags
-> IO VkPipelineRasterizationStateCreateFlags
Ptr VkPipelineRasterizationStateCreateFlags
-> Int -> IO VkPipelineRasterizationStateCreateFlags
Ptr VkPipelineRasterizationStateCreateFlags
-> Int -> VkPipelineRasterizationStateCreateFlags -> IO ()
Ptr VkPipelineRasterizationStateCreateFlags
-> VkPipelineRasterizationStateCreateFlags -> IO ()
VkPipelineRasterizationStateCreateFlags -> Int
(VkPipelineRasterizationStateCreateFlags -> Int)
-> (VkPipelineRasterizationStateCreateFlags -> Int)
-> (Ptr VkPipelineRasterizationStateCreateFlags
    -> Int -> IO VkPipelineRasterizationStateCreateFlags)
-> (Ptr VkPipelineRasterizationStateCreateFlags
    -> Int -> VkPipelineRasterizationStateCreateFlags -> IO ())
-> (forall b.
    Ptr b -> Int -> IO VkPipelineRasterizationStateCreateFlags)
-> (forall b.
    Ptr b -> Int -> VkPipelineRasterizationStateCreateFlags -> IO ())
-> (Ptr VkPipelineRasterizationStateCreateFlags
    -> IO VkPipelineRasterizationStateCreateFlags)
-> (Ptr VkPipelineRasterizationStateCreateFlags
    -> VkPipelineRasterizationStateCreateFlags -> IO ())
-> Storable VkPipelineRasterizationStateCreateFlags
forall b.
Ptr b -> Int -> IO VkPipelineRasterizationStateCreateFlags
forall b.
Ptr b -> Int -> VkPipelineRasterizationStateCreateFlags -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr VkPipelineRasterizationStateCreateFlags
-> VkPipelineRasterizationStateCreateFlags -> IO ()
$cpoke :: Ptr VkPipelineRasterizationStateCreateFlags
-> VkPipelineRasterizationStateCreateFlags -> IO ()
peek :: Ptr VkPipelineRasterizationStateCreateFlags
-> IO VkPipelineRasterizationStateCreateFlags
$cpeek :: Ptr VkPipelineRasterizationStateCreateFlags
-> IO VkPipelineRasterizationStateCreateFlags
pokeByteOff :: forall b.
Ptr b -> Int -> VkPipelineRasterizationStateCreateFlags -> IO ()
$cpokeByteOff :: forall b.
Ptr b -> Int -> VkPipelineRasterizationStateCreateFlags -> IO ()
peekByteOff :: forall b.
Ptr b -> Int -> IO VkPipelineRasterizationStateCreateFlags
$cpeekByteOff :: forall b.
Ptr b -> Int -> IO VkPipelineRasterizationStateCreateFlags
pokeElemOff :: Ptr VkPipelineRasterizationStateCreateFlags
-> Int -> VkPipelineRasterizationStateCreateFlags -> IO ()
$cpokeElemOff :: Ptr VkPipelineRasterizationStateCreateFlags
-> Int -> VkPipelineRasterizationStateCreateFlags -> IO ()
peekElemOff :: Ptr VkPipelineRasterizationStateCreateFlags
-> Int -> IO VkPipelineRasterizationStateCreateFlags
$cpeekElemOff :: Ptr VkPipelineRasterizationStateCreateFlags
-> Int -> IO VkPipelineRasterizationStateCreateFlags
alignment :: VkPipelineRasterizationStateCreateFlags -> Int
$calignment :: VkPipelineRasterizationStateCreateFlags -> Int
sizeOf :: VkPipelineRasterizationStateCreateFlags -> Int
$csizeOf :: VkPipelineRasterizationStateCreateFlags -> Int
Storable)

instance Show VkPipelineRasterizationStateCreateFlags where
    {-# INLINE showsPrec #-}
    showsPrec :: Int -> VkPipelineRasterizationStateCreateFlags -> ShowS
showsPrec = (Int -> VkFlags -> ShowS)
-> Int -> VkPipelineRasterizationStateCreateFlags -> ShowS
coerce (Int -> VkFlags -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec :: Int -> VkFlags -> ShowS)

instance Read VkPipelineRasterizationStateCreateFlags where
    {-# INLINE readsPrec #-}
    readsPrec :: Int -> ReadS VkPipelineRasterizationStateCreateFlags
readsPrec = (Int -> ReadS VkFlags)
-> Int -> ReadS VkPipelineRasterizationStateCreateFlags
coerce (Int -> ReadS VkFlags
forall a. Read a => Int -> ReadS a
readsPrec :: Int -> ReadS VkFlags)

newtype VkPipelineRasterizationStateStreamCreateFlagsEXT = VkPipelineRasterizationStateStreamCreateFlagsEXT VkFlags
                                                           deriving (VkPipelineRasterizationStateStreamCreateFlagsEXT
-> VkPipelineRasterizationStateStreamCreateFlagsEXT -> Bool
(VkPipelineRasterizationStateStreamCreateFlagsEXT
 -> VkPipelineRasterizationStateStreamCreateFlagsEXT -> Bool)
-> (VkPipelineRasterizationStateStreamCreateFlagsEXT
    -> VkPipelineRasterizationStateStreamCreateFlagsEXT -> Bool)
-> Eq VkPipelineRasterizationStateStreamCreateFlagsEXT
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VkPipelineRasterizationStateStreamCreateFlagsEXT
-> VkPipelineRasterizationStateStreamCreateFlagsEXT -> Bool
$c/= :: VkPipelineRasterizationStateStreamCreateFlagsEXT
-> VkPipelineRasterizationStateStreamCreateFlagsEXT -> Bool
== :: VkPipelineRasterizationStateStreamCreateFlagsEXT
-> VkPipelineRasterizationStateStreamCreateFlagsEXT -> Bool
$c== :: VkPipelineRasterizationStateStreamCreateFlagsEXT
-> VkPipelineRasterizationStateStreamCreateFlagsEXT -> Bool
Eq, Eq VkPipelineRasterizationStateStreamCreateFlagsEXT
Eq VkPipelineRasterizationStateStreamCreateFlagsEXT
-> (VkPipelineRasterizationStateStreamCreateFlagsEXT
    -> VkPipelineRasterizationStateStreamCreateFlagsEXT -> Ordering)
-> (VkPipelineRasterizationStateStreamCreateFlagsEXT
    -> VkPipelineRasterizationStateStreamCreateFlagsEXT -> Bool)
-> (VkPipelineRasterizationStateStreamCreateFlagsEXT
    -> VkPipelineRasterizationStateStreamCreateFlagsEXT -> Bool)
-> (VkPipelineRasterizationStateStreamCreateFlagsEXT
    -> VkPipelineRasterizationStateStreamCreateFlagsEXT -> Bool)
-> (VkPipelineRasterizationStateStreamCreateFlagsEXT
    -> VkPipelineRasterizationStateStreamCreateFlagsEXT -> Bool)
-> (VkPipelineRasterizationStateStreamCreateFlagsEXT
    -> VkPipelineRasterizationStateStreamCreateFlagsEXT
    -> VkPipelineRasterizationStateStreamCreateFlagsEXT)
-> (VkPipelineRasterizationStateStreamCreateFlagsEXT
    -> VkPipelineRasterizationStateStreamCreateFlagsEXT
    -> VkPipelineRasterizationStateStreamCreateFlagsEXT)
-> Ord VkPipelineRasterizationStateStreamCreateFlagsEXT
VkPipelineRasterizationStateStreamCreateFlagsEXT
-> VkPipelineRasterizationStateStreamCreateFlagsEXT -> Bool
VkPipelineRasterizationStateStreamCreateFlagsEXT
-> VkPipelineRasterizationStateStreamCreateFlagsEXT -> Ordering
VkPipelineRasterizationStateStreamCreateFlagsEXT
-> VkPipelineRasterizationStateStreamCreateFlagsEXT
-> VkPipelineRasterizationStateStreamCreateFlagsEXT
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: VkPipelineRasterizationStateStreamCreateFlagsEXT
-> VkPipelineRasterizationStateStreamCreateFlagsEXT
-> VkPipelineRasterizationStateStreamCreateFlagsEXT
$cmin :: VkPipelineRasterizationStateStreamCreateFlagsEXT
-> VkPipelineRasterizationStateStreamCreateFlagsEXT
-> VkPipelineRasterizationStateStreamCreateFlagsEXT
max :: VkPipelineRasterizationStateStreamCreateFlagsEXT
-> VkPipelineRasterizationStateStreamCreateFlagsEXT
-> VkPipelineRasterizationStateStreamCreateFlagsEXT
$cmax :: VkPipelineRasterizationStateStreamCreateFlagsEXT
-> VkPipelineRasterizationStateStreamCreateFlagsEXT
-> VkPipelineRasterizationStateStreamCreateFlagsEXT
>= :: VkPipelineRasterizationStateStreamCreateFlagsEXT
-> VkPipelineRasterizationStateStreamCreateFlagsEXT -> Bool
$c>= :: VkPipelineRasterizationStateStreamCreateFlagsEXT
-> VkPipelineRasterizationStateStreamCreateFlagsEXT -> Bool
> :: VkPipelineRasterizationStateStreamCreateFlagsEXT
-> VkPipelineRasterizationStateStreamCreateFlagsEXT -> Bool
$c> :: VkPipelineRasterizationStateStreamCreateFlagsEXT
-> VkPipelineRasterizationStateStreamCreateFlagsEXT -> Bool
<= :: VkPipelineRasterizationStateStreamCreateFlagsEXT
-> VkPipelineRasterizationStateStreamCreateFlagsEXT -> Bool
$c<= :: VkPipelineRasterizationStateStreamCreateFlagsEXT
-> VkPipelineRasterizationStateStreamCreateFlagsEXT -> Bool
< :: VkPipelineRasterizationStateStreamCreateFlagsEXT
-> VkPipelineRasterizationStateStreamCreateFlagsEXT -> Bool
$c< :: VkPipelineRasterizationStateStreamCreateFlagsEXT
-> VkPipelineRasterizationStateStreamCreateFlagsEXT -> Bool
compare :: VkPipelineRasterizationStateStreamCreateFlagsEXT
-> VkPipelineRasterizationStateStreamCreateFlagsEXT -> Ordering
$ccompare :: VkPipelineRasterizationStateStreamCreateFlagsEXT
-> VkPipelineRasterizationStateStreamCreateFlagsEXT -> Ordering
Ord, Int -> VkPipelineRasterizationStateStreamCreateFlagsEXT
VkPipelineRasterizationStateStreamCreateFlagsEXT -> Int
VkPipelineRasterizationStateStreamCreateFlagsEXT
-> [VkPipelineRasterizationStateStreamCreateFlagsEXT]
VkPipelineRasterizationStateStreamCreateFlagsEXT
-> VkPipelineRasterizationStateStreamCreateFlagsEXT
VkPipelineRasterizationStateStreamCreateFlagsEXT
-> VkPipelineRasterizationStateStreamCreateFlagsEXT
-> [VkPipelineRasterizationStateStreamCreateFlagsEXT]
VkPipelineRasterizationStateStreamCreateFlagsEXT
-> VkPipelineRasterizationStateStreamCreateFlagsEXT
-> VkPipelineRasterizationStateStreamCreateFlagsEXT
-> [VkPipelineRasterizationStateStreamCreateFlagsEXT]
(VkPipelineRasterizationStateStreamCreateFlagsEXT
 -> VkPipelineRasterizationStateStreamCreateFlagsEXT)
-> (VkPipelineRasterizationStateStreamCreateFlagsEXT
    -> VkPipelineRasterizationStateStreamCreateFlagsEXT)
-> (Int -> VkPipelineRasterizationStateStreamCreateFlagsEXT)
-> (VkPipelineRasterizationStateStreamCreateFlagsEXT -> Int)
-> (VkPipelineRasterizationStateStreamCreateFlagsEXT
    -> [VkPipelineRasterizationStateStreamCreateFlagsEXT])
-> (VkPipelineRasterizationStateStreamCreateFlagsEXT
    -> VkPipelineRasterizationStateStreamCreateFlagsEXT
    -> [VkPipelineRasterizationStateStreamCreateFlagsEXT])
-> (VkPipelineRasterizationStateStreamCreateFlagsEXT
    -> VkPipelineRasterizationStateStreamCreateFlagsEXT
    -> [VkPipelineRasterizationStateStreamCreateFlagsEXT])
-> (VkPipelineRasterizationStateStreamCreateFlagsEXT
    -> VkPipelineRasterizationStateStreamCreateFlagsEXT
    -> VkPipelineRasterizationStateStreamCreateFlagsEXT
    -> [VkPipelineRasterizationStateStreamCreateFlagsEXT])
-> Enum VkPipelineRasterizationStateStreamCreateFlagsEXT
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: VkPipelineRasterizationStateStreamCreateFlagsEXT
-> VkPipelineRasterizationStateStreamCreateFlagsEXT
-> VkPipelineRasterizationStateStreamCreateFlagsEXT
-> [VkPipelineRasterizationStateStreamCreateFlagsEXT]
$cenumFromThenTo :: VkPipelineRasterizationStateStreamCreateFlagsEXT
-> VkPipelineRasterizationStateStreamCreateFlagsEXT
-> VkPipelineRasterizationStateStreamCreateFlagsEXT
-> [VkPipelineRasterizationStateStreamCreateFlagsEXT]
enumFromTo :: VkPipelineRasterizationStateStreamCreateFlagsEXT
-> VkPipelineRasterizationStateStreamCreateFlagsEXT
-> [VkPipelineRasterizationStateStreamCreateFlagsEXT]
$cenumFromTo :: VkPipelineRasterizationStateStreamCreateFlagsEXT
-> VkPipelineRasterizationStateStreamCreateFlagsEXT
-> [VkPipelineRasterizationStateStreamCreateFlagsEXT]
enumFromThen :: VkPipelineRasterizationStateStreamCreateFlagsEXT
-> VkPipelineRasterizationStateStreamCreateFlagsEXT
-> [VkPipelineRasterizationStateStreamCreateFlagsEXT]
$cenumFromThen :: VkPipelineRasterizationStateStreamCreateFlagsEXT
-> VkPipelineRasterizationStateStreamCreateFlagsEXT
-> [VkPipelineRasterizationStateStreamCreateFlagsEXT]
enumFrom :: VkPipelineRasterizationStateStreamCreateFlagsEXT
-> [VkPipelineRasterizationStateStreamCreateFlagsEXT]
$cenumFrom :: VkPipelineRasterizationStateStreamCreateFlagsEXT
-> [VkPipelineRasterizationStateStreamCreateFlagsEXT]
fromEnum :: VkPipelineRasterizationStateStreamCreateFlagsEXT -> Int
$cfromEnum :: VkPipelineRasterizationStateStreamCreateFlagsEXT -> Int
toEnum :: Int -> VkPipelineRasterizationStateStreamCreateFlagsEXT
$ctoEnum :: Int -> VkPipelineRasterizationStateStreamCreateFlagsEXT
pred :: VkPipelineRasterizationStateStreamCreateFlagsEXT
-> VkPipelineRasterizationStateStreamCreateFlagsEXT
$cpred :: VkPipelineRasterizationStateStreamCreateFlagsEXT
-> VkPipelineRasterizationStateStreamCreateFlagsEXT
succ :: VkPipelineRasterizationStateStreamCreateFlagsEXT
-> VkPipelineRasterizationStateStreamCreateFlagsEXT
$csucc :: VkPipelineRasterizationStateStreamCreateFlagsEXT
-> VkPipelineRasterizationStateStreamCreateFlagsEXT
Enum, Eq VkPipelineRasterizationStateStreamCreateFlagsEXT
VkPipelineRasterizationStateStreamCreateFlagsEXT
Eq VkPipelineRasterizationStateStreamCreateFlagsEXT
-> (VkPipelineRasterizationStateStreamCreateFlagsEXT
    -> VkPipelineRasterizationStateStreamCreateFlagsEXT
    -> VkPipelineRasterizationStateStreamCreateFlagsEXT)
-> (VkPipelineRasterizationStateStreamCreateFlagsEXT
    -> VkPipelineRasterizationStateStreamCreateFlagsEXT
    -> VkPipelineRasterizationStateStreamCreateFlagsEXT)
-> (VkPipelineRasterizationStateStreamCreateFlagsEXT
    -> VkPipelineRasterizationStateStreamCreateFlagsEXT
    -> VkPipelineRasterizationStateStreamCreateFlagsEXT)
-> (VkPipelineRasterizationStateStreamCreateFlagsEXT
    -> VkPipelineRasterizationStateStreamCreateFlagsEXT)
-> (VkPipelineRasterizationStateStreamCreateFlagsEXT
    -> Int -> VkPipelineRasterizationStateStreamCreateFlagsEXT)
-> (VkPipelineRasterizationStateStreamCreateFlagsEXT
    -> Int -> VkPipelineRasterizationStateStreamCreateFlagsEXT)
-> VkPipelineRasterizationStateStreamCreateFlagsEXT
-> (Int -> VkPipelineRasterizationStateStreamCreateFlagsEXT)
-> (VkPipelineRasterizationStateStreamCreateFlagsEXT
    -> Int -> VkPipelineRasterizationStateStreamCreateFlagsEXT)
-> (VkPipelineRasterizationStateStreamCreateFlagsEXT
    -> Int -> VkPipelineRasterizationStateStreamCreateFlagsEXT)
-> (VkPipelineRasterizationStateStreamCreateFlagsEXT
    -> Int -> VkPipelineRasterizationStateStreamCreateFlagsEXT)
-> (VkPipelineRasterizationStateStreamCreateFlagsEXT
    -> Int -> Bool)
-> (VkPipelineRasterizationStateStreamCreateFlagsEXT -> Maybe Int)
-> (VkPipelineRasterizationStateStreamCreateFlagsEXT -> Int)
-> (VkPipelineRasterizationStateStreamCreateFlagsEXT -> Bool)
-> (VkPipelineRasterizationStateStreamCreateFlagsEXT
    -> Int -> VkPipelineRasterizationStateStreamCreateFlagsEXT)
-> (VkPipelineRasterizationStateStreamCreateFlagsEXT
    -> Int -> VkPipelineRasterizationStateStreamCreateFlagsEXT)
-> (VkPipelineRasterizationStateStreamCreateFlagsEXT
    -> Int -> VkPipelineRasterizationStateStreamCreateFlagsEXT)
-> (VkPipelineRasterizationStateStreamCreateFlagsEXT
    -> Int -> VkPipelineRasterizationStateStreamCreateFlagsEXT)
-> (VkPipelineRasterizationStateStreamCreateFlagsEXT
    -> Int -> VkPipelineRasterizationStateStreamCreateFlagsEXT)
-> (VkPipelineRasterizationStateStreamCreateFlagsEXT
    -> Int -> VkPipelineRasterizationStateStreamCreateFlagsEXT)
-> (VkPipelineRasterizationStateStreamCreateFlagsEXT -> Int)
-> Bits VkPipelineRasterizationStateStreamCreateFlagsEXT
Int -> VkPipelineRasterizationStateStreamCreateFlagsEXT
VkPipelineRasterizationStateStreamCreateFlagsEXT -> Bool
VkPipelineRasterizationStateStreamCreateFlagsEXT -> Int
VkPipelineRasterizationStateStreamCreateFlagsEXT -> Maybe Int
VkPipelineRasterizationStateStreamCreateFlagsEXT
-> VkPipelineRasterizationStateStreamCreateFlagsEXT
VkPipelineRasterizationStateStreamCreateFlagsEXT -> Int -> Bool
VkPipelineRasterizationStateStreamCreateFlagsEXT
-> Int -> VkPipelineRasterizationStateStreamCreateFlagsEXT
VkPipelineRasterizationStateStreamCreateFlagsEXT
-> VkPipelineRasterizationStateStreamCreateFlagsEXT
-> VkPipelineRasterizationStateStreamCreateFlagsEXT
forall a.
Eq a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
popCount :: VkPipelineRasterizationStateStreamCreateFlagsEXT -> Int
$cpopCount :: VkPipelineRasterizationStateStreamCreateFlagsEXT -> Int
rotateR :: VkPipelineRasterizationStateStreamCreateFlagsEXT
-> Int -> VkPipelineRasterizationStateStreamCreateFlagsEXT
$crotateR :: VkPipelineRasterizationStateStreamCreateFlagsEXT
-> Int -> VkPipelineRasterizationStateStreamCreateFlagsEXT
rotateL :: VkPipelineRasterizationStateStreamCreateFlagsEXT
-> Int -> VkPipelineRasterizationStateStreamCreateFlagsEXT
$crotateL :: VkPipelineRasterizationStateStreamCreateFlagsEXT
-> Int -> VkPipelineRasterizationStateStreamCreateFlagsEXT
unsafeShiftR :: VkPipelineRasterizationStateStreamCreateFlagsEXT
-> Int -> VkPipelineRasterizationStateStreamCreateFlagsEXT
$cunsafeShiftR :: VkPipelineRasterizationStateStreamCreateFlagsEXT
-> Int -> VkPipelineRasterizationStateStreamCreateFlagsEXT
shiftR :: VkPipelineRasterizationStateStreamCreateFlagsEXT
-> Int -> VkPipelineRasterizationStateStreamCreateFlagsEXT
$cshiftR :: VkPipelineRasterizationStateStreamCreateFlagsEXT
-> Int -> VkPipelineRasterizationStateStreamCreateFlagsEXT
unsafeShiftL :: VkPipelineRasterizationStateStreamCreateFlagsEXT
-> Int -> VkPipelineRasterizationStateStreamCreateFlagsEXT
$cunsafeShiftL :: VkPipelineRasterizationStateStreamCreateFlagsEXT
-> Int -> VkPipelineRasterizationStateStreamCreateFlagsEXT
shiftL :: VkPipelineRasterizationStateStreamCreateFlagsEXT
-> Int -> VkPipelineRasterizationStateStreamCreateFlagsEXT
$cshiftL :: VkPipelineRasterizationStateStreamCreateFlagsEXT
-> Int -> VkPipelineRasterizationStateStreamCreateFlagsEXT
isSigned :: VkPipelineRasterizationStateStreamCreateFlagsEXT -> Bool
$cisSigned :: VkPipelineRasterizationStateStreamCreateFlagsEXT -> Bool
bitSize :: VkPipelineRasterizationStateStreamCreateFlagsEXT -> Int
$cbitSize :: VkPipelineRasterizationStateStreamCreateFlagsEXT -> Int
bitSizeMaybe :: VkPipelineRasterizationStateStreamCreateFlagsEXT -> Maybe Int
$cbitSizeMaybe :: VkPipelineRasterizationStateStreamCreateFlagsEXT -> Maybe Int
testBit :: VkPipelineRasterizationStateStreamCreateFlagsEXT -> Int -> Bool
$ctestBit :: VkPipelineRasterizationStateStreamCreateFlagsEXT -> Int -> Bool
complementBit :: VkPipelineRasterizationStateStreamCreateFlagsEXT
-> Int -> VkPipelineRasterizationStateStreamCreateFlagsEXT
$ccomplementBit :: VkPipelineRasterizationStateStreamCreateFlagsEXT
-> Int -> VkPipelineRasterizationStateStreamCreateFlagsEXT
clearBit :: VkPipelineRasterizationStateStreamCreateFlagsEXT
-> Int -> VkPipelineRasterizationStateStreamCreateFlagsEXT
$cclearBit :: VkPipelineRasterizationStateStreamCreateFlagsEXT
-> Int -> VkPipelineRasterizationStateStreamCreateFlagsEXT
setBit :: VkPipelineRasterizationStateStreamCreateFlagsEXT
-> Int -> VkPipelineRasterizationStateStreamCreateFlagsEXT
$csetBit :: VkPipelineRasterizationStateStreamCreateFlagsEXT
-> Int -> VkPipelineRasterizationStateStreamCreateFlagsEXT
bit :: Int -> VkPipelineRasterizationStateStreamCreateFlagsEXT
$cbit :: Int -> VkPipelineRasterizationStateStreamCreateFlagsEXT
zeroBits :: VkPipelineRasterizationStateStreamCreateFlagsEXT
$czeroBits :: VkPipelineRasterizationStateStreamCreateFlagsEXT
rotate :: VkPipelineRasterizationStateStreamCreateFlagsEXT
-> Int -> VkPipelineRasterizationStateStreamCreateFlagsEXT
$crotate :: VkPipelineRasterizationStateStreamCreateFlagsEXT
-> Int -> VkPipelineRasterizationStateStreamCreateFlagsEXT
shift :: VkPipelineRasterizationStateStreamCreateFlagsEXT
-> Int -> VkPipelineRasterizationStateStreamCreateFlagsEXT
$cshift :: VkPipelineRasterizationStateStreamCreateFlagsEXT
-> Int -> VkPipelineRasterizationStateStreamCreateFlagsEXT
complement :: VkPipelineRasterizationStateStreamCreateFlagsEXT
-> VkPipelineRasterizationStateStreamCreateFlagsEXT
$ccomplement :: VkPipelineRasterizationStateStreamCreateFlagsEXT
-> VkPipelineRasterizationStateStreamCreateFlagsEXT
xor :: VkPipelineRasterizationStateStreamCreateFlagsEXT
-> VkPipelineRasterizationStateStreamCreateFlagsEXT
-> VkPipelineRasterizationStateStreamCreateFlagsEXT
$cxor :: VkPipelineRasterizationStateStreamCreateFlagsEXT
-> VkPipelineRasterizationStateStreamCreateFlagsEXT
-> VkPipelineRasterizationStateStreamCreateFlagsEXT
.|. :: VkPipelineRasterizationStateStreamCreateFlagsEXT
-> VkPipelineRasterizationStateStreamCreateFlagsEXT
-> VkPipelineRasterizationStateStreamCreateFlagsEXT
$c.|. :: VkPipelineRasterizationStateStreamCreateFlagsEXT
-> VkPipelineRasterizationStateStreamCreateFlagsEXT
-> VkPipelineRasterizationStateStreamCreateFlagsEXT
.&. :: VkPipelineRasterizationStateStreamCreateFlagsEXT
-> VkPipelineRasterizationStateStreamCreateFlagsEXT
-> VkPipelineRasterizationStateStreamCreateFlagsEXT
$c.&. :: VkPipelineRasterizationStateStreamCreateFlagsEXT
-> VkPipelineRasterizationStateStreamCreateFlagsEXT
-> VkPipelineRasterizationStateStreamCreateFlagsEXT
Bits,
                                                                     Bits VkPipelineRasterizationStateStreamCreateFlagsEXT
Bits VkPipelineRasterizationStateStreamCreateFlagsEXT
-> (VkPipelineRasterizationStateStreamCreateFlagsEXT -> Int)
-> (VkPipelineRasterizationStateStreamCreateFlagsEXT -> Int)
-> (VkPipelineRasterizationStateStreamCreateFlagsEXT -> Int)
-> FiniteBits VkPipelineRasterizationStateStreamCreateFlagsEXT
VkPipelineRasterizationStateStreamCreateFlagsEXT -> Int
forall b.
Bits b -> (b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
countTrailingZeros :: VkPipelineRasterizationStateStreamCreateFlagsEXT -> Int
$ccountTrailingZeros :: VkPipelineRasterizationStateStreamCreateFlagsEXT -> Int
countLeadingZeros :: VkPipelineRasterizationStateStreamCreateFlagsEXT -> Int
$ccountLeadingZeros :: VkPipelineRasterizationStateStreamCreateFlagsEXT -> Int
finiteBitSize :: VkPipelineRasterizationStateStreamCreateFlagsEXT -> Int
$cfiniteBitSize :: VkPipelineRasterizationStateStreamCreateFlagsEXT -> Int
FiniteBits, Ptr VkPipelineRasterizationStateStreamCreateFlagsEXT
-> IO VkPipelineRasterizationStateStreamCreateFlagsEXT
Ptr VkPipelineRasterizationStateStreamCreateFlagsEXT
-> Int -> IO VkPipelineRasterizationStateStreamCreateFlagsEXT
Ptr VkPipelineRasterizationStateStreamCreateFlagsEXT
-> Int -> VkPipelineRasterizationStateStreamCreateFlagsEXT -> IO ()
Ptr VkPipelineRasterizationStateStreamCreateFlagsEXT
-> VkPipelineRasterizationStateStreamCreateFlagsEXT -> IO ()
VkPipelineRasterizationStateStreamCreateFlagsEXT -> Int
(VkPipelineRasterizationStateStreamCreateFlagsEXT -> Int)
-> (VkPipelineRasterizationStateStreamCreateFlagsEXT -> Int)
-> (Ptr VkPipelineRasterizationStateStreamCreateFlagsEXT
    -> Int -> IO VkPipelineRasterizationStateStreamCreateFlagsEXT)
-> (Ptr VkPipelineRasterizationStateStreamCreateFlagsEXT
    -> Int
    -> VkPipelineRasterizationStateStreamCreateFlagsEXT
    -> IO ())
-> (forall b.
    Ptr b
    -> Int -> IO VkPipelineRasterizationStateStreamCreateFlagsEXT)
-> (forall b.
    Ptr b
    -> Int
    -> VkPipelineRasterizationStateStreamCreateFlagsEXT
    -> IO ())
-> (Ptr VkPipelineRasterizationStateStreamCreateFlagsEXT
    -> IO VkPipelineRasterizationStateStreamCreateFlagsEXT)
-> (Ptr VkPipelineRasterizationStateStreamCreateFlagsEXT
    -> VkPipelineRasterizationStateStreamCreateFlagsEXT -> IO ())
-> Storable VkPipelineRasterizationStateStreamCreateFlagsEXT
forall b.
Ptr b -> Int -> IO VkPipelineRasterizationStateStreamCreateFlagsEXT
forall b.
Ptr b
-> Int -> VkPipelineRasterizationStateStreamCreateFlagsEXT -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr VkPipelineRasterizationStateStreamCreateFlagsEXT
-> VkPipelineRasterizationStateStreamCreateFlagsEXT -> IO ()
$cpoke :: Ptr VkPipelineRasterizationStateStreamCreateFlagsEXT
-> VkPipelineRasterizationStateStreamCreateFlagsEXT -> IO ()
peek :: Ptr VkPipelineRasterizationStateStreamCreateFlagsEXT
-> IO VkPipelineRasterizationStateStreamCreateFlagsEXT
$cpeek :: Ptr VkPipelineRasterizationStateStreamCreateFlagsEXT
-> IO VkPipelineRasterizationStateStreamCreateFlagsEXT
pokeByteOff :: forall b.
Ptr b
-> Int -> VkPipelineRasterizationStateStreamCreateFlagsEXT -> IO ()
$cpokeByteOff :: forall b.
Ptr b
-> Int -> VkPipelineRasterizationStateStreamCreateFlagsEXT -> IO ()
peekByteOff :: forall b.
Ptr b -> Int -> IO VkPipelineRasterizationStateStreamCreateFlagsEXT
$cpeekByteOff :: forall b.
Ptr b -> Int -> IO VkPipelineRasterizationStateStreamCreateFlagsEXT
pokeElemOff :: Ptr VkPipelineRasterizationStateStreamCreateFlagsEXT
-> Int -> VkPipelineRasterizationStateStreamCreateFlagsEXT -> IO ()
$cpokeElemOff :: Ptr VkPipelineRasterizationStateStreamCreateFlagsEXT
-> Int -> VkPipelineRasterizationStateStreamCreateFlagsEXT -> IO ()
peekElemOff :: Ptr VkPipelineRasterizationStateStreamCreateFlagsEXT
-> Int -> IO VkPipelineRasterizationStateStreamCreateFlagsEXT
$cpeekElemOff :: Ptr VkPipelineRasterizationStateStreamCreateFlagsEXT
-> Int -> IO VkPipelineRasterizationStateStreamCreateFlagsEXT
alignment :: VkPipelineRasterizationStateStreamCreateFlagsEXT -> Int
$calignment :: VkPipelineRasterizationStateStreamCreateFlagsEXT -> Int
sizeOf :: VkPipelineRasterizationStateStreamCreateFlagsEXT -> Int
$csizeOf :: VkPipelineRasterizationStateStreamCreateFlagsEXT -> Int
Storable)

instance Show VkPipelineRasterizationStateStreamCreateFlagsEXT
         where
    {-# INLINE showsPrec #-}
    showsPrec :: Int -> VkPipelineRasterizationStateStreamCreateFlagsEXT -> ShowS
showsPrec = (Int -> VkFlags -> ShowS)
-> Int -> VkPipelineRasterizationStateStreamCreateFlagsEXT -> ShowS
coerce (Int -> VkFlags -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec :: Int -> VkFlags -> ShowS)

instance Read VkPipelineRasterizationStateStreamCreateFlagsEXT
         where
    {-# INLINE readsPrec #-}
    readsPrec :: Int -> ReadS VkPipelineRasterizationStateStreamCreateFlagsEXT
readsPrec = (Int -> ReadS VkFlags)
-> Int -> ReadS VkPipelineRasterizationStateStreamCreateFlagsEXT
coerce (Int -> ReadS VkFlags
forall a. Read a => Int -> ReadS a
readsPrec :: Int -> ReadS VkFlags)

newtype VkPipelineTessellationStateCreateFlags = VkPipelineTessellationStateCreateFlags VkFlags
                                                 deriving (VkPipelineTessellationStateCreateFlags
-> VkPipelineTessellationStateCreateFlags -> Bool
(VkPipelineTessellationStateCreateFlags
 -> VkPipelineTessellationStateCreateFlags -> Bool)
-> (VkPipelineTessellationStateCreateFlags
    -> VkPipelineTessellationStateCreateFlags -> Bool)
-> Eq VkPipelineTessellationStateCreateFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VkPipelineTessellationStateCreateFlags
-> VkPipelineTessellationStateCreateFlags -> Bool
$c/= :: VkPipelineTessellationStateCreateFlags
-> VkPipelineTessellationStateCreateFlags -> Bool
== :: VkPipelineTessellationStateCreateFlags
-> VkPipelineTessellationStateCreateFlags -> Bool
$c== :: VkPipelineTessellationStateCreateFlags
-> VkPipelineTessellationStateCreateFlags -> Bool
Eq, Eq VkPipelineTessellationStateCreateFlags
Eq VkPipelineTessellationStateCreateFlags
-> (VkPipelineTessellationStateCreateFlags
    -> VkPipelineTessellationStateCreateFlags -> Ordering)
-> (VkPipelineTessellationStateCreateFlags
    -> VkPipelineTessellationStateCreateFlags -> Bool)
-> (VkPipelineTessellationStateCreateFlags
    -> VkPipelineTessellationStateCreateFlags -> Bool)
-> (VkPipelineTessellationStateCreateFlags
    -> VkPipelineTessellationStateCreateFlags -> Bool)
-> (VkPipelineTessellationStateCreateFlags
    -> VkPipelineTessellationStateCreateFlags -> Bool)
-> (VkPipelineTessellationStateCreateFlags
    -> VkPipelineTessellationStateCreateFlags
    -> VkPipelineTessellationStateCreateFlags)
-> (VkPipelineTessellationStateCreateFlags
    -> VkPipelineTessellationStateCreateFlags
    -> VkPipelineTessellationStateCreateFlags)
-> Ord VkPipelineTessellationStateCreateFlags
VkPipelineTessellationStateCreateFlags
-> VkPipelineTessellationStateCreateFlags -> Bool
VkPipelineTessellationStateCreateFlags
-> VkPipelineTessellationStateCreateFlags -> Ordering
VkPipelineTessellationStateCreateFlags
-> VkPipelineTessellationStateCreateFlags
-> VkPipelineTessellationStateCreateFlags
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: VkPipelineTessellationStateCreateFlags
-> VkPipelineTessellationStateCreateFlags
-> VkPipelineTessellationStateCreateFlags
$cmin :: VkPipelineTessellationStateCreateFlags
-> VkPipelineTessellationStateCreateFlags
-> VkPipelineTessellationStateCreateFlags
max :: VkPipelineTessellationStateCreateFlags
-> VkPipelineTessellationStateCreateFlags
-> VkPipelineTessellationStateCreateFlags
$cmax :: VkPipelineTessellationStateCreateFlags
-> VkPipelineTessellationStateCreateFlags
-> VkPipelineTessellationStateCreateFlags
>= :: VkPipelineTessellationStateCreateFlags
-> VkPipelineTessellationStateCreateFlags -> Bool
$c>= :: VkPipelineTessellationStateCreateFlags
-> VkPipelineTessellationStateCreateFlags -> Bool
> :: VkPipelineTessellationStateCreateFlags
-> VkPipelineTessellationStateCreateFlags -> Bool
$c> :: VkPipelineTessellationStateCreateFlags
-> VkPipelineTessellationStateCreateFlags -> Bool
<= :: VkPipelineTessellationStateCreateFlags
-> VkPipelineTessellationStateCreateFlags -> Bool
$c<= :: VkPipelineTessellationStateCreateFlags
-> VkPipelineTessellationStateCreateFlags -> Bool
< :: VkPipelineTessellationStateCreateFlags
-> VkPipelineTessellationStateCreateFlags -> Bool
$c< :: VkPipelineTessellationStateCreateFlags
-> VkPipelineTessellationStateCreateFlags -> Bool
compare :: VkPipelineTessellationStateCreateFlags
-> VkPipelineTessellationStateCreateFlags -> Ordering
$ccompare :: VkPipelineTessellationStateCreateFlags
-> VkPipelineTessellationStateCreateFlags -> Ordering
Ord, Int -> VkPipelineTessellationStateCreateFlags
VkPipelineTessellationStateCreateFlags -> Int
VkPipelineTessellationStateCreateFlags
-> [VkPipelineTessellationStateCreateFlags]
VkPipelineTessellationStateCreateFlags
-> VkPipelineTessellationStateCreateFlags
VkPipelineTessellationStateCreateFlags
-> VkPipelineTessellationStateCreateFlags
-> [VkPipelineTessellationStateCreateFlags]
VkPipelineTessellationStateCreateFlags
-> VkPipelineTessellationStateCreateFlags
-> VkPipelineTessellationStateCreateFlags
-> [VkPipelineTessellationStateCreateFlags]
(VkPipelineTessellationStateCreateFlags
 -> VkPipelineTessellationStateCreateFlags)
-> (VkPipelineTessellationStateCreateFlags
    -> VkPipelineTessellationStateCreateFlags)
-> (Int -> VkPipelineTessellationStateCreateFlags)
-> (VkPipelineTessellationStateCreateFlags -> Int)
-> (VkPipelineTessellationStateCreateFlags
    -> [VkPipelineTessellationStateCreateFlags])
-> (VkPipelineTessellationStateCreateFlags
    -> VkPipelineTessellationStateCreateFlags
    -> [VkPipelineTessellationStateCreateFlags])
-> (VkPipelineTessellationStateCreateFlags
    -> VkPipelineTessellationStateCreateFlags
    -> [VkPipelineTessellationStateCreateFlags])
-> (VkPipelineTessellationStateCreateFlags
    -> VkPipelineTessellationStateCreateFlags
    -> VkPipelineTessellationStateCreateFlags
    -> [VkPipelineTessellationStateCreateFlags])
-> Enum VkPipelineTessellationStateCreateFlags
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: VkPipelineTessellationStateCreateFlags
-> VkPipelineTessellationStateCreateFlags
-> VkPipelineTessellationStateCreateFlags
-> [VkPipelineTessellationStateCreateFlags]
$cenumFromThenTo :: VkPipelineTessellationStateCreateFlags
-> VkPipelineTessellationStateCreateFlags
-> VkPipelineTessellationStateCreateFlags
-> [VkPipelineTessellationStateCreateFlags]
enumFromTo :: VkPipelineTessellationStateCreateFlags
-> VkPipelineTessellationStateCreateFlags
-> [VkPipelineTessellationStateCreateFlags]
$cenumFromTo :: VkPipelineTessellationStateCreateFlags
-> VkPipelineTessellationStateCreateFlags
-> [VkPipelineTessellationStateCreateFlags]
enumFromThen :: VkPipelineTessellationStateCreateFlags
-> VkPipelineTessellationStateCreateFlags
-> [VkPipelineTessellationStateCreateFlags]
$cenumFromThen :: VkPipelineTessellationStateCreateFlags
-> VkPipelineTessellationStateCreateFlags
-> [VkPipelineTessellationStateCreateFlags]
enumFrom :: VkPipelineTessellationStateCreateFlags
-> [VkPipelineTessellationStateCreateFlags]
$cenumFrom :: VkPipelineTessellationStateCreateFlags
-> [VkPipelineTessellationStateCreateFlags]
fromEnum :: VkPipelineTessellationStateCreateFlags -> Int
$cfromEnum :: VkPipelineTessellationStateCreateFlags -> Int
toEnum :: Int -> VkPipelineTessellationStateCreateFlags
$ctoEnum :: Int -> VkPipelineTessellationStateCreateFlags
pred :: VkPipelineTessellationStateCreateFlags
-> VkPipelineTessellationStateCreateFlags
$cpred :: VkPipelineTessellationStateCreateFlags
-> VkPipelineTessellationStateCreateFlags
succ :: VkPipelineTessellationStateCreateFlags
-> VkPipelineTessellationStateCreateFlags
$csucc :: VkPipelineTessellationStateCreateFlags
-> VkPipelineTessellationStateCreateFlags
Enum, Eq VkPipelineTessellationStateCreateFlags
VkPipelineTessellationStateCreateFlags
Eq VkPipelineTessellationStateCreateFlags
-> (VkPipelineTessellationStateCreateFlags
    -> VkPipelineTessellationStateCreateFlags
    -> VkPipelineTessellationStateCreateFlags)
-> (VkPipelineTessellationStateCreateFlags
    -> VkPipelineTessellationStateCreateFlags
    -> VkPipelineTessellationStateCreateFlags)
-> (VkPipelineTessellationStateCreateFlags
    -> VkPipelineTessellationStateCreateFlags
    -> VkPipelineTessellationStateCreateFlags)
-> (VkPipelineTessellationStateCreateFlags
    -> VkPipelineTessellationStateCreateFlags)
-> (VkPipelineTessellationStateCreateFlags
    -> Int -> VkPipelineTessellationStateCreateFlags)
-> (VkPipelineTessellationStateCreateFlags
    -> Int -> VkPipelineTessellationStateCreateFlags)
-> VkPipelineTessellationStateCreateFlags
-> (Int -> VkPipelineTessellationStateCreateFlags)
-> (VkPipelineTessellationStateCreateFlags
    -> Int -> VkPipelineTessellationStateCreateFlags)
-> (VkPipelineTessellationStateCreateFlags
    -> Int -> VkPipelineTessellationStateCreateFlags)
-> (VkPipelineTessellationStateCreateFlags
    -> Int -> VkPipelineTessellationStateCreateFlags)
-> (VkPipelineTessellationStateCreateFlags -> Int -> Bool)
-> (VkPipelineTessellationStateCreateFlags -> Maybe Int)
-> (VkPipelineTessellationStateCreateFlags -> Int)
-> (VkPipelineTessellationStateCreateFlags -> Bool)
-> (VkPipelineTessellationStateCreateFlags
    -> Int -> VkPipelineTessellationStateCreateFlags)
-> (VkPipelineTessellationStateCreateFlags
    -> Int -> VkPipelineTessellationStateCreateFlags)
-> (VkPipelineTessellationStateCreateFlags
    -> Int -> VkPipelineTessellationStateCreateFlags)
-> (VkPipelineTessellationStateCreateFlags
    -> Int -> VkPipelineTessellationStateCreateFlags)
-> (VkPipelineTessellationStateCreateFlags
    -> Int -> VkPipelineTessellationStateCreateFlags)
-> (VkPipelineTessellationStateCreateFlags
    -> Int -> VkPipelineTessellationStateCreateFlags)
-> (VkPipelineTessellationStateCreateFlags -> Int)
-> Bits VkPipelineTessellationStateCreateFlags
Int -> VkPipelineTessellationStateCreateFlags
VkPipelineTessellationStateCreateFlags -> Bool
VkPipelineTessellationStateCreateFlags -> Int
VkPipelineTessellationStateCreateFlags -> Maybe Int
VkPipelineTessellationStateCreateFlags
-> VkPipelineTessellationStateCreateFlags
VkPipelineTessellationStateCreateFlags -> Int -> Bool
VkPipelineTessellationStateCreateFlags
-> Int -> VkPipelineTessellationStateCreateFlags
VkPipelineTessellationStateCreateFlags
-> VkPipelineTessellationStateCreateFlags
-> VkPipelineTessellationStateCreateFlags
forall a.
Eq a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
popCount :: VkPipelineTessellationStateCreateFlags -> Int
$cpopCount :: VkPipelineTessellationStateCreateFlags -> Int
rotateR :: VkPipelineTessellationStateCreateFlags
-> Int -> VkPipelineTessellationStateCreateFlags
$crotateR :: VkPipelineTessellationStateCreateFlags
-> Int -> VkPipelineTessellationStateCreateFlags
rotateL :: VkPipelineTessellationStateCreateFlags
-> Int -> VkPipelineTessellationStateCreateFlags
$crotateL :: VkPipelineTessellationStateCreateFlags
-> Int -> VkPipelineTessellationStateCreateFlags
unsafeShiftR :: VkPipelineTessellationStateCreateFlags
-> Int -> VkPipelineTessellationStateCreateFlags
$cunsafeShiftR :: VkPipelineTessellationStateCreateFlags
-> Int -> VkPipelineTessellationStateCreateFlags
shiftR :: VkPipelineTessellationStateCreateFlags
-> Int -> VkPipelineTessellationStateCreateFlags
$cshiftR :: VkPipelineTessellationStateCreateFlags
-> Int -> VkPipelineTessellationStateCreateFlags
unsafeShiftL :: VkPipelineTessellationStateCreateFlags
-> Int -> VkPipelineTessellationStateCreateFlags
$cunsafeShiftL :: VkPipelineTessellationStateCreateFlags
-> Int -> VkPipelineTessellationStateCreateFlags
shiftL :: VkPipelineTessellationStateCreateFlags
-> Int -> VkPipelineTessellationStateCreateFlags
$cshiftL :: VkPipelineTessellationStateCreateFlags
-> Int -> VkPipelineTessellationStateCreateFlags
isSigned :: VkPipelineTessellationStateCreateFlags -> Bool
$cisSigned :: VkPipelineTessellationStateCreateFlags -> Bool
bitSize :: VkPipelineTessellationStateCreateFlags -> Int
$cbitSize :: VkPipelineTessellationStateCreateFlags -> Int
bitSizeMaybe :: VkPipelineTessellationStateCreateFlags -> Maybe Int
$cbitSizeMaybe :: VkPipelineTessellationStateCreateFlags -> Maybe Int
testBit :: VkPipelineTessellationStateCreateFlags -> Int -> Bool
$ctestBit :: VkPipelineTessellationStateCreateFlags -> Int -> Bool
complementBit :: VkPipelineTessellationStateCreateFlags
-> Int -> VkPipelineTessellationStateCreateFlags
$ccomplementBit :: VkPipelineTessellationStateCreateFlags
-> Int -> VkPipelineTessellationStateCreateFlags
clearBit :: VkPipelineTessellationStateCreateFlags
-> Int -> VkPipelineTessellationStateCreateFlags
$cclearBit :: VkPipelineTessellationStateCreateFlags
-> Int -> VkPipelineTessellationStateCreateFlags
setBit :: VkPipelineTessellationStateCreateFlags
-> Int -> VkPipelineTessellationStateCreateFlags
$csetBit :: VkPipelineTessellationStateCreateFlags
-> Int -> VkPipelineTessellationStateCreateFlags
bit :: Int -> VkPipelineTessellationStateCreateFlags
$cbit :: Int -> VkPipelineTessellationStateCreateFlags
zeroBits :: VkPipelineTessellationStateCreateFlags
$czeroBits :: VkPipelineTessellationStateCreateFlags
rotate :: VkPipelineTessellationStateCreateFlags
-> Int -> VkPipelineTessellationStateCreateFlags
$crotate :: VkPipelineTessellationStateCreateFlags
-> Int -> VkPipelineTessellationStateCreateFlags
shift :: VkPipelineTessellationStateCreateFlags
-> Int -> VkPipelineTessellationStateCreateFlags
$cshift :: VkPipelineTessellationStateCreateFlags
-> Int -> VkPipelineTessellationStateCreateFlags
complement :: VkPipelineTessellationStateCreateFlags
-> VkPipelineTessellationStateCreateFlags
$ccomplement :: VkPipelineTessellationStateCreateFlags
-> VkPipelineTessellationStateCreateFlags
xor :: VkPipelineTessellationStateCreateFlags
-> VkPipelineTessellationStateCreateFlags
-> VkPipelineTessellationStateCreateFlags
$cxor :: VkPipelineTessellationStateCreateFlags
-> VkPipelineTessellationStateCreateFlags
-> VkPipelineTessellationStateCreateFlags
.|. :: VkPipelineTessellationStateCreateFlags
-> VkPipelineTessellationStateCreateFlags
-> VkPipelineTessellationStateCreateFlags
$c.|. :: VkPipelineTessellationStateCreateFlags
-> VkPipelineTessellationStateCreateFlags
-> VkPipelineTessellationStateCreateFlags
.&. :: VkPipelineTessellationStateCreateFlags
-> VkPipelineTessellationStateCreateFlags
-> VkPipelineTessellationStateCreateFlags
$c.&. :: VkPipelineTessellationStateCreateFlags
-> VkPipelineTessellationStateCreateFlags
-> VkPipelineTessellationStateCreateFlags
Bits, Bits VkPipelineTessellationStateCreateFlags
Bits VkPipelineTessellationStateCreateFlags
-> (VkPipelineTessellationStateCreateFlags -> Int)
-> (VkPipelineTessellationStateCreateFlags -> Int)
-> (VkPipelineTessellationStateCreateFlags -> Int)
-> FiniteBits VkPipelineTessellationStateCreateFlags
VkPipelineTessellationStateCreateFlags -> Int
forall b.
Bits b -> (b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
countTrailingZeros :: VkPipelineTessellationStateCreateFlags -> Int
$ccountTrailingZeros :: VkPipelineTessellationStateCreateFlags -> Int
countLeadingZeros :: VkPipelineTessellationStateCreateFlags -> Int
$ccountLeadingZeros :: VkPipelineTessellationStateCreateFlags -> Int
finiteBitSize :: VkPipelineTessellationStateCreateFlags -> Int
$cfiniteBitSize :: VkPipelineTessellationStateCreateFlags -> Int
FiniteBits,
                                                           Ptr VkPipelineTessellationStateCreateFlags
-> IO VkPipelineTessellationStateCreateFlags
Ptr VkPipelineTessellationStateCreateFlags
-> Int -> IO VkPipelineTessellationStateCreateFlags
Ptr VkPipelineTessellationStateCreateFlags
-> Int -> VkPipelineTessellationStateCreateFlags -> IO ()
Ptr VkPipelineTessellationStateCreateFlags
-> VkPipelineTessellationStateCreateFlags -> IO ()
VkPipelineTessellationStateCreateFlags -> Int
(VkPipelineTessellationStateCreateFlags -> Int)
-> (VkPipelineTessellationStateCreateFlags -> Int)
-> (Ptr VkPipelineTessellationStateCreateFlags
    -> Int -> IO VkPipelineTessellationStateCreateFlags)
-> (Ptr VkPipelineTessellationStateCreateFlags
    -> Int -> VkPipelineTessellationStateCreateFlags -> IO ())
-> (forall b.
    Ptr b -> Int -> IO VkPipelineTessellationStateCreateFlags)
-> (forall b.
    Ptr b -> Int -> VkPipelineTessellationStateCreateFlags -> IO ())
-> (Ptr VkPipelineTessellationStateCreateFlags
    -> IO VkPipelineTessellationStateCreateFlags)
-> (Ptr VkPipelineTessellationStateCreateFlags
    -> VkPipelineTessellationStateCreateFlags -> IO ())
-> Storable VkPipelineTessellationStateCreateFlags
forall b. Ptr b -> Int -> IO VkPipelineTessellationStateCreateFlags
forall b.
Ptr b -> Int -> VkPipelineTessellationStateCreateFlags -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr VkPipelineTessellationStateCreateFlags
-> VkPipelineTessellationStateCreateFlags -> IO ()
$cpoke :: Ptr VkPipelineTessellationStateCreateFlags
-> VkPipelineTessellationStateCreateFlags -> IO ()
peek :: Ptr VkPipelineTessellationStateCreateFlags
-> IO VkPipelineTessellationStateCreateFlags
$cpeek :: Ptr VkPipelineTessellationStateCreateFlags
-> IO VkPipelineTessellationStateCreateFlags
pokeByteOff :: forall b.
Ptr b -> Int -> VkPipelineTessellationStateCreateFlags -> IO ()
$cpokeByteOff :: forall b.
Ptr b -> Int -> VkPipelineTessellationStateCreateFlags -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO VkPipelineTessellationStateCreateFlags
$cpeekByteOff :: forall b. Ptr b -> Int -> IO VkPipelineTessellationStateCreateFlags
pokeElemOff :: Ptr VkPipelineTessellationStateCreateFlags
-> Int -> VkPipelineTessellationStateCreateFlags -> IO ()
$cpokeElemOff :: Ptr VkPipelineTessellationStateCreateFlags
-> Int -> VkPipelineTessellationStateCreateFlags -> IO ()
peekElemOff :: Ptr VkPipelineTessellationStateCreateFlags
-> Int -> IO VkPipelineTessellationStateCreateFlags
$cpeekElemOff :: Ptr VkPipelineTessellationStateCreateFlags
-> Int -> IO VkPipelineTessellationStateCreateFlags
alignment :: VkPipelineTessellationStateCreateFlags -> Int
$calignment :: VkPipelineTessellationStateCreateFlags -> Int
sizeOf :: VkPipelineTessellationStateCreateFlags -> Int
$csizeOf :: VkPipelineTessellationStateCreateFlags -> Int
Storable)

instance Show VkPipelineTessellationStateCreateFlags where
    {-# INLINE showsPrec #-}
    showsPrec :: Int -> VkPipelineTessellationStateCreateFlags -> ShowS
showsPrec = (Int -> VkFlags -> ShowS)
-> Int -> VkPipelineTessellationStateCreateFlags -> ShowS
coerce (Int -> VkFlags -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec :: Int -> VkFlags -> ShowS)

instance Read VkPipelineTessellationStateCreateFlags where
    {-# INLINE readsPrec #-}
    readsPrec :: Int -> ReadS VkPipelineTessellationStateCreateFlags
readsPrec = (Int -> ReadS VkFlags)
-> Int -> ReadS VkPipelineTessellationStateCreateFlags
coerce (Int -> ReadS VkFlags
forall a. Read a => Int -> ReadS a
readsPrec :: Int -> ReadS VkFlags)

newtype VkPipelineVertexInputStateCreateFlags = VkPipelineVertexInputStateCreateFlags VkFlags
                                                deriving (VkPipelineVertexInputStateCreateFlags
-> VkPipelineVertexInputStateCreateFlags -> Bool
(VkPipelineVertexInputStateCreateFlags
 -> VkPipelineVertexInputStateCreateFlags -> Bool)
-> (VkPipelineVertexInputStateCreateFlags
    -> VkPipelineVertexInputStateCreateFlags -> Bool)
-> Eq VkPipelineVertexInputStateCreateFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VkPipelineVertexInputStateCreateFlags
-> VkPipelineVertexInputStateCreateFlags -> Bool
$c/= :: VkPipelineVertexInputStateCreateFlags
-> VkPipelineVertexInputStateCreateFlags -> Bool
== :: VkPipelineVertexInputStateCreateFlags
-> VkPipelineVertexInputStateCreateFlags -> Bool
$c== :: VkPipelineVertexInputStateCreateFlags
-> VkPipelineVertexInputStateCreateFlags -> Bool
Eq, Eq VkPipelineVertexInputStateCreateFlags
Eq VkPipelineVertexInputStateCreateFlags
-> (VkPipelineVertexInputStateCreateFlags
    -> VkPipelineVertexInputStateCreateFlags -> Ordering)
-> (VkPipelineVertexInputStateCreateFlags
    -> VkPipelineVertexInputStateCreateFlags -> Bool)
-> (VkPipelineVertexInputStateCreateFlags
    -> VkPipelineVertexInputStateCreateFlags -> Bool)
-> (VkPipelineVertexInputStateCreateFlags
    -> VkPipelineVertexInputStateCreateFlags -> Bool)
-> (VkPipelineVertexInputStateCreateFlags
    -> VkPipelineVertexInputStateCreateFlags -> Bool)
-> (VkPipelineVertexInputStateCreateFlags
    -> VkPipelineVertexInputStateCreateFlags
    -> VkPipelineVertexInputStateCreateFlags)
-> (VkPipelineVertexInputStateCreateFlags
    -> VkPipelineVertexInputStateCreateFlags
    -> VkPipelineVertexInputStateCreateFlags)
-> Ord VkPipelineVertexInputStateCreateFlags
VkPipelineVertexInputStateCreateFlags
-> VkPipelineVertexInputStateCreateFlags -> Bool
VkPipelineVertexInputStateCreateFlags
-> VkPipelineVertexInputStateCreateFlags -> Ordering
VkPipelineVertexInputStateCreateFlags
-> VkPipelineVertexInputStateCreateFlags
-> VkPipelineVertexInputStateCreateFlags
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: VkPipelineVertexInputStateCreateFlags
-> VkPipelineVertexInputStateCreateFlags
-> VkPipelineVertexInputStateCreateFlags
$cmin :: VkPipelineVertexInputStateCreateFlags
-> VkPipelineVertexInputStateCreateFlags
-> VkPipelineVertexInputStateCreateFlags
max :: VkPipelineVertexInputStateCreateFlags
-> VkPipelineVertexInputStateCreateFlags
-> VkPipelineVertexInputStateCreateFlags
$cmax :: VkPipelineVertexInputStateCreateFlags
-> VkPipelineVertexInputStateCreateFlags
-> VkPipelineVertexInputStateCreateFlags
>= :: VkPipelineVertexInputStateCreateFlags
-> VkPipelineVertexInputStateCreateFlags -> Bool
$c>= :: VkPipelineVertexInputStateCreateFlags
-> VkPipelineVertexInputStateCreateFlags -> Bool
> :: VkPipelineVertexInputStateCreateFlags
-> VkPipelineVertexInputStateCreateFlags -> Bool
$c> :: VkPipelineVertexInputStateCreateFlags
-> VkPipelineVertexInputStateCreateFlags -> Bool
<= :: VkPipelineVertexInputStateCreateFlags
-> VkPipelineVertexInputStateCreateFlags -> Bool
$c<= :: VkPipelineVertexInputStateCreateFlags
-> VkPipelineVertexInputStateCreateFlags -> Bool
< :: VkPipelineVertexInputStateCreateFlags
-> VkPipelineVertexInputStateCreateFlags -> Bool
$c< :: VkPipelineVertexInputStateCreateFlags
-> VkPipelineVertexInputStateCreateFlags -> Bool
compare :: VkPipelineVertexInputStateCreateFlags
-> VkPipelineVertexInputStateCreateFlags -> Ordering
$ccompare :: VkPipelineVertexInputStateCreateFlags
-> VkPipelineVertexInputStateCreateFlags -> Ordering
Ord, Int -> VkPipelineVertexInputStateCreateFlags
VkPipelineVertexInputStateCreateFlags -> Int
VkPipelineVertexInputStateCreateFlags
-> [VkPipelineVertexInputStateCreateFlags]
VkPipelineVertexInputStateCreateFlags
-> VkPipelineVertexInputStateCreateFlags
VkPipelineVertexInputStateCreateFlags
-> VkPipelineVertexInputStateCreateFlags
-> [VkPipelineVertexInputStateCreateFlags]
VkPipelineVertexInputStateCreateFlags
-> VkPipelineVertexInputStateCreateFlags
-> VkPipelineVertexInputStateCreateFlags
-> [VkPipelineVertexInputStateCreateFlags]
(VkPipelineVertexInputStateCreateFlags
 -> VkPipelineVertexInputStateCreateFlags)
-> (VkPipelineVertexInputStateCreateFlags
    -> VkPipelineVertexInputStateCreateFlags)
-> (Int -> VkPipelineVertexInputStateCreateFlags)
-> (VkPipelineVertexInputStateCreateFlags -> Int)
-> (VkPipelineVertexInputStateCreateFlags
    -> [VkPipelineVertexInputStateCreateFlags])
-> (VkPipelineVertexInputStateCreateFlags
    -> VkPipelineVertexInputStateCreateFlags
    -> [VkPipelineVertexInputStateCreateFlags])
-> (VkPipelineVertexInputStateCreateFlags
    -> VkPipelineVertexInputStateCreateFlags
    -> [VkPipelineVertexInputStateCreateFlags])
-> (VkPipelineVertexInputStateCreateFlags
    -> VkPipelineVertexInputStateCreateFlags
    -> VkPipelineVertexInputStateCreateFlags
    -> [VkPipelineVertexInputStateCreateFlags])
-> Enum VkPipelineVertexInputStateCreateFlags
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: VkPipelineVertexInputStateCreateFlags
-> VkPipelineVertexInputStateCreateFlags
-> VkPipelineVertexInputStateCreateFlags
-> [VkPipelineVertexInputStateCreateFlags]
$cenumFromThenTo :: VkPipelineVertexInputStateCreateFlags
-> VkPipelineVertexInputStateCreateFlags
-> VkPipelineVertexInputStateCreateFlags
-> [VkPipelineVertexInputStateCreateFlags]
enumFromTo :: VkPipelineVertexInputStateCreateFlags
-> VkPipelineVertexInputStateCreateFlags
-> [VkPipelineVertexInputStateCreateFlags]
$cenumFromTo :: VkPipelineVertexInputStateCreateFlags
-> VkPipelineVertexInputStateCreateFlags
-> [VkPipelineVertexInputStateCreateFlags]
enumFromThen :: VkPipelineVertexInputStateCreateFlags
-> VkPipelineVertexInputStateCreateFlags
-> [VkPipelineVertexInputStateCreateFlags]
$cenumFromThen :: VkPipelineVertexInputStateCreateFlags
-> VkPipelineVertexInputStateCreateFlags
-> [VkPipelineVertexInputStateCreateFlags]
enumFrom :: VkPipelineVertexInputStateCreateFlags
-> [VkPipelineVertexInputStateCreateFlags]
$cenumFrom :: VkPipelineVertexInputStateCreateFlags
-> [VkPipelineVertexInputStateCreateFlags]
fromEnum :: VkPipelineVertexInputStateCreateFlags -> Int
$cfromEnum :: VkPipelineVertexInputStateCreateFlags -> Int
toEnum :: Int -> VkPipelineVertexInputStateCreateFlags
$ctoEnum :: Int -> VkPipelineVertexInputStateCreateFlags
pred :: VkPipelineVertexInputStateCreateFlags
-> VkPipelineVertexInputStateCreateFlags
$cpred :: VkPipelineVertexInputStateCreateFlags
-> VkPipelineVertexInputStateCreateFlags
succ :: VkPipelineVertexInputStateCreateFlags
-> VkPipelineVertexInputStateCreateFlags
$csucc :: VkPipelineVertexInputStateCreateFlags
-> VkPipelineVertexInputStateCreateFlags
Enum, Eq VkPipelineVertexInputStateCreateFlags
VkPipelineVertexInputStateCreateFlags
Eq VkPipelineVertexInputStateCreateFlags
-> (VkPipelineVertexInputStateCreateFlags
    -> VkPipelineVertexInputStateCreateFlags
    -> VkPipelineVertexInputStateCreateFlags)
-> (VkPipelineVertexInputStateCreateFlags
    -> VkPipelineVertexInputStateCreateFlags
    -> VkPipelineVertexInputStateCreateFlags)
-> (VkPipelineVertexInputStateCreateFlags
    -> VkPipelineVertexInputStateCreateFlags
    -> VkPipelineVertexInputStateCreateFlags)
-> (VkPipelineVertexInputStateCreateFlags
    -> VkPipelineVertexInputStateCreateFlags)
-> (VkPipelineVertexInputStateCreateFlags
    -> Int -> VkPipelineVertexInputStateCreateFlags)
-> (VkPipelineVertexInputStateCreateFlags
    -> Int -> VkPipelineVertexInputStateCreateFlags)
-> VkPipelineVertexInputStateCreateFlags
-> (Int -> VkPipelineVertexInputStateCreateFlags)
-> (VkPipelineVertexInputStateCreateFlags
    -> Int -> VkPipelineVertexInputStateCreateFlags)
-> (VkPipelineVertexInputStateCreateFlags
    -> Int -> VkPipelineVertexInputStateCreateFlags)
-> (VkPipelineVertexInputStateCreateFlags
    -> Int -> VkPipelineVertexInputStateCreateFlags)
-> (VkPipelineVertexInputStateCreateFlags -> Int -> Bool)
-> (VkPipelineVertexInputStateCreateFlags -> Maybe Int)
-> (VkPipelineVertexInputStateCreateFlags -> Int)
-> (VkPipelineVertexInputStateCreateFlags -> Bool)
-> (VkPipelineVertexInputStateCreateFlags
    -> Int -> VkPipelineVertexInputStateCreateFlags)
-> (VkPipelineVertexInputStateCreateFlags
    -> Int -> VkPipelineVertexInputStateCreateFlags)
-> (VkPipelineVertexInputStateCreateFlags
    -> Int -> VkPipelineVertexInputStateCreateFlags)
-> (VkPipelineVertexInputStateCreateFlags
    -> Int -> VkPipelineVertexInputStateCreateFlags)
-> (VkPipelineVertexInputStateCreateFlags
    -> Int -> VkPipelineVertexInputStateCreateFlags)
-> (VkPipelineVertexInputStateCreateFlags
    -> Int -> VkPipelineVertexInputStateCreateFlags)
-> (VkPipelineVertexInputStateCreateFlags -> Int)
-> Bits VkPipelineVertexInputStateCreateFlags
Int -> VkPipelineVertexInputStateCreateFlags
VkPipelineVertexInputStateCreateFlags -> Bool
VkPipelineVertexInputStateCreateFlags -> Int
VkPipelineVertexInputStateCreateFlags -> Maybe Int
VkPipelineVertexInputStateCreateFlags
-> VkPipelineVertexInputStateCreateFlags
VkPipelineVertexInputStateCreateFlags -> Int -> Bool
VkPipelineVertexInputStateCreateFlags
-> Int -> VkPipelineVertexInputStateCreateFlags
VkPipelineVertexInputStateCreateFlags
-> VkPipelineVertexInputStateCreateFlags
-> VkPipelineVertexInputStateCreateFlags
forall a.
Eq a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
popCount :: VkPipelineVertexInputStateCreateFlags -> Int
$cpopCount :: VkPipelineVertexInputStateCreateFlags -> Int
rotateR :: VkPipelineVertexInputStateCreateFlags
-> Int -> VkPipelineVertexInputStateCreateFlags
$crotateR :: VkPipelineVertexInputStateCreateFlags
-> Int -> VkPipelineVertexInputStateCreateFlags
rotateL :: VkPipelineVertexInputStateCreateFlags
-> Int -> VkPipelineVertexInputStateCreateFlags
$crotateL :: VkPipelineVertexInputStateCreateFlags
-> Int -> VkPipelineVertexInputStateCreateFlags
unsafeShiftR :: VkPipelineVertexInputStateCreateFlags
-> Int -> VkPipelineVertexInputStateCreateFlags
$cunsafeShiftR :: VkPipelineVertexInputStateCreateFlags
-> Int -> VkPipelineVertexInputStateCreateFlags
shiftR :: VkPipelineVertexInputStateCreateFlags
-> Int -> VkPipelineVertexInputStateCreateFlags
$cshiftR :: VkPipelineVertexInputStateCreateFlags
-> Int -> VkPipelineVertexInputStateCreateFlags
unsafeShiftL :: VkPipelineVertexInputStateCreateFlags
-> Int -> VkPipelineVertexInputStateCreateFlags
$cunsafeShiftL :: VkPipelineVertexInputStateCreateFlags
-> Int -> VkPipelineVertexInputStateCreateFlags
shiftL :: VkPipelineVertexInputStateCreateFlags
-> Int -> VkPipelineVertexInputStateCreateFlags
$cshiftL :: VkPipelineVertexInputStateCreateFlags
-> Int -> VkPipelineVertexInputStateCreateFlags
isSigned :: VkPipelineVertexInputStateCreateFlags -> Bool
$cisSigned :: VkPipelineVertexInputStateCreateFlags -> Bool
bitSize :: VkPipelineVertexInputStateCreateFlags -> Int
$cbitSize :: VkPipelineVertexInputStateCreateFlags -> Int
bitSizeMaybe :: VkPipelineVertexInputStateCreateFlags -> Maybe Int
$cbitSizeMaybe :: VkPipelineVertexInputStateCreateFlags -> Maybe Int
testBit :: VkPipelineVertexInputStateCreateFlags -> Int -> Bool
$ctestBit :: VkPipelineVertexInputStateCreateFlags -> Int -> Bool
complementBit :: VkPipelineVertexInputStateCreateFlags
-> Int -> VkPipelineVertexInputStateCreateFlags
$ccomplementBit :: VkPipelineVertexInputStateCreateFlags
-> Int -> VkPipelineVertexInputStateCreateFlags
clearBit :: VkPipelineVertexInputStateCreateFlags
-> Int -> VkPipelineVertexInputStateCreateFlags
$cclearBit :: VkPipelineVertexInputStateCreateFlags
-> Int -> VkPipelineVertexInputStateCreateFlags
setBit :: VkPipelineVertexInputStateCreateFlags
-> Int -> VkPipelineVertexInputStateCreateFlags
$csetBit :: VkPipelineVertexInputStateCreateFlags
-> Int -> VkPipelineVertexInputStateCreateFlags
bit :: Int -> VkPipelineVertexInputStateCreateFlags
$cbit :: Int -> VkPipelineVertexInputStateCreateFlags
zeroBits :: VkPipelineVertexInputStateCreateFlags
$czeroBits :: VkPipelineVertexInputStateCreateFlags
rotate :: VkPipelineVertexInputStateCreateFlags
-> Int -> VkPipelineVertexInputStateCreateFlags
$crotate :: VkPipelineVertexInputStateCreateFlags
-> Int -> VkPipelineVertexInputStateCreateFlags
shift :: VkPipelineVertexInputStateCreateFlags
-> Int -> VkPipelineVertexInputStateCreateFlags
$cshift :: VkPipelineVertexInputStateCreateFlags
-> Int -> VkPipelineVertexInputStateCreateFlags
complement :: VkPipelineVertexInputStateCreateFlags
-> VkPipelineVertexInputStateCreateFlags
$ccomplement :: VkPipelineVertexInputStateCreateFlags
-> VkPipelineVertexInputStateCreateFlags
xor :: VkPipelineVertexInputStateCreateFlags
-> VkPipelineVertexInputStateCreateFlags
-> VkPipelineVertexInputStateCreateFlags
$cxor :: VkPipelineVertexInputStateCreateFlags
-> VkPipelineVertexInputStateCreateFlags
-> VkPipelineVertexInputStateCreateFlags
.|. :: VkPipelineVertexInputStateCreateFlags
-> VkPipelineVertexInputStateCreateFlags
-> VkPipelineVertexInputStateCreateFlags
$c.|. :: VkPipelineVertexInputStateCreateFlags
-> VkPipelineVertexInputStateCreateFlags
-> VkPipelineVertexInputStateCreateFlags
.&. :: VkPipelineVertexInputStateCreateFlags
-> VkPipelineVertexInputStateCreateFlags
-> VkPipelineVertexInputStateCreateFlags
$c.&. :: VkPipelineVertexInputStateCreateFlags
-> VkPipelineVertexInputStateCreateFlags
-> VkPipelineVertexInputStateCreateFlags
Bits, Bits VkPipelineVertexInputStateCreateFlags
Bits VkPipelineVertexInputStateCreateFlags
-> (VkPipelineVertexInputStateCreateFlags -> Int)
-> (VkPipelineVertexInputStateCreateFlags -> Int)
-> (VkPipelineVertexInputStateCreateFlags -> Int)
-> FiniteBits VkPipelineVertexInputStateCreateFlags
VkPipelineVertexInputStateCreateFlags -> Int
forall b.
Bits b -> (b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
countTrailingZeros :: VkPipelineVertexInputStateCreateFlags -> Int
$ccountTrailingZeros :: VkPipelineVertexInputStateCreateFlags -> Int
countLeadingZeros :: VkPipelineVertexInputStateCreateFlags -> Int
$ccountLeadingZeros :: VkPipelineVertexInputStateCreateFlags -> Int
finiteBitSize :: VkPipelineVertexInputStateCreateFlags -> Int
$cfiniteBitSize :: VkPipelineVertexInputStateCreateFlags -> Int
FiniteBits, Ptr VkPipelineVertexInputStateCreateFlags
-> IO VkPipelineVertexInputStateCreateFlags
Ptr VkPipelineVertexInputStateCreateFlags
-> Int -> IO VkPipelineVertexInputStateCreateFlags
Ptr VkPipelineVertexInputStateCreateFlags
-> Int -> VkPipelineVertexInputStateCreateFlags -> IO ()
Ptr VkPipelineVertexInputStateCreateFlags
-> VkPipelineVertexInputStateCreateFlags -> IO ()
VkPipelineVertexInputStateCreateFlags -> Int
(VkPipelineVertexInputStateCreateFlags -> Int)
-> (VkPipelineVertexInputStateCreateFlags -> Int)
-> (Ptr VkPipelineVertexInputStateCreateFlags
    -> Int -> IO VkPipelineVertexInputStateCreateFlags)
-> (Ptr VkPipelineVertexInputStateCreateFlags
    -> Int -> VkPipelineVertexInputStateCreateFlags -> IO ())
-> (forall b.
    Ptr b -> Int -> IO VkPipelineVertexInputStateCreateFlags)
-> (forall b.
    Ptr b -> Int -> VkPipelineVertexInputStateCreateFlags -> IO ())
-> (Ptr VkPipelineVertexInputStateCreateFlags
    -> IO VkPipelineVertexInputStateCreateFlags)
-> (Ptr VkPipelineVertexInputStateCreateFlags
    -> VkPipelineVertexInputStateCreateFlags -> IO ())
-> Storable VkPipelineVertexInputStateCreateFlags
forall b. Ptr b -> Int -> IO VkPipelineVertexInputStateCreateFlags
forall b.
Ptr b -> Int -> VkPipelineVertexInputStateCreateFlags -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr VkPipelineVertexInputStateCreateFlags
-> VkPipelineVertexInputStateCreateFlags -> IO ()
$cpoke :: Ptr VkPipelineVertexInputStateCreateFlags
-> VkPipelineVertexInputStateCreateFlags -> IO ()
peek :: Ptr VkPipelineVertexInputStateCreateFlags
-> IO VkPipelineVertexInputStateCreateFlags
$cpeek :: Ptr VkPipelineVertexInputStateCreateFlags
-> IO VkPipelineVertexInputStateCreateFlags
pokeByteOff :: forall b.
Ptr b -> Int -> VkPipelineVertexInputStateCreateFlags -> IO ()
$cpokeByteOff :: forall b.
Ptr b -> Int -> VkPipelineVertexInputStateCreateFlags -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO VkPipelineVertexInputStateCreateFlags
$cpeekByteOff :: forall b. Ptr b -> Int -> IO VkPipelineVertexInputStateCreateFlags
pokeElemOff :: Ptr VkPipelineVertexInputStateCreateFlags
-> Int -> VkPipelineVertexInputStateCreateFlags -> IO ()
$cpokeElemOff :: Ptr VkPipelineVertexInputStateCreateFlags
-> Int -> VkPipelineVertexInputStateCreateFlags -> IO ()
peekElemOff :: Ptr VkPipelineVertexInputStateCreateFlags
-> Int -> IO VkPipelineVertexInputStateCreateFlags
$cpeekElemOff :: Ptr VkPipelineVertexInputStateCreateFlags
-> Int -> IO VkPipelineVertexInputStateCreateFlags
alignment :: VkPipelineVertexInputStateCreateFlags -> Int
$calignment :: VkPipelineVertexInputStateCreateFlags -> Int
sizeOf :: VkPipelineVertexInputStateCreateFlags -> Int
$csizeOf :: VkPipelineVertexInputStateCreateFlags -> Int
Storable)

instance Show VkPipelineVertexInputStateCreateFlags where
    {-# INLINE showsPrec #-}
    showsPrec :: Int -> VkPipelineVertexInputStateCreateFlags -> ShowS
showsPrec = (Int -> VkFlags -> ShowS)
-> Int -> VkPipelineVertexInputStateCreateFlags -> ShowS
coerce (Int -> VkFlags -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec :: Int -> VkFlags -> ShowS)

instance Read VkPipelineVertexInputStateCreateFlags where
    {-# INLINE readsPrec #-}
    readsPrec :: Int -> ReadS VkPipelineVertexInputStateCreateFlags
readsPrec = (Int -> ReadS VkFlags)
-> Int -> ReadS VkPipelineVertexInputStateCreateFlags
coerce (Int -> ReadS VkFlags
forall a. Read a => Int -> ReadS a
readsPrec :: Int -> ReadS VkFlags)

newtype VkPipelineViewportStateCreateFlags = VkPipelineViewportStateCreateFlags VkFlags
                                             deriving (VkPipelineViewportStateCreateFlags
-> VkPipelineViewportStateCreateFlags -> Bool
(VkPipelineViewportStateCreateFlags
 -> VkPipelineViewportStateCreateFlags -> Bool)
-> (VkPipelineViewportStateCreateFlags
    -> VkPipelineViewportStateCreateFlags -> Bool)
-> Eq VkPipelineViewportStateCreateFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VkPipelineViewportStateCreateFlags
-> VkPipelineViewportStateCreateFlags -> Bool
$c/= :: VkPipelineViewportStateCreateFlags
-> VkPipelineViewportStateCreateFlags -> Bool
== :: VkPipelineViewportStateCreateFlags
-> VkPipelineViewportStateCreateFlags -> Bool
$c== :: VkPipelineViewportStateCreateFlags
-> VkPipelineViewportStateCreateFlags -> Bool
Eq, Eq VkPipelineViewportStateCreateFlags
Eq VkPipelineViewportStateCreateFlags
-> (VkPipelineViewportStateCreateFlags
    -> VkPipelineViewportStateCreateFlags -> Ordering)
-> (VkPipelineViewportStateCreateFlags
    -> VkPipelineViewportStateCreateFlags -> Bool)
-> (VkPipelineViewportStateCreateFlags
    -> VkPipelineViewportStateCreateFlags -> Bool)
-> (VkPipelineViewportStateCreateFlags
    -> VkPipelineViewportStateCreateFlags -> Bool)
-> (VkPipelineViewportStateCreateFlags
    -> VkPipelineViewportStateCreateFlags -> Bool)
-> (VkPipelineViewportStateCreateFlags
    -> VkPipelineViewportStateCreateFlags
    -> VkPipelineViewportStateCreateFlags)
-> (VkPipelineViewportStateCreateFlags
    -> VkPipelineViewportStateCreateFlags
    -> VkPipelineViewportStateCreateFlags)
-> Ord VkPipelineViewportStateCreateFlags
VkPipelineViewportStateCreateFlags
-> VkPipelineViewportStateCreateFlags -> Bool
VkPipelineViewportStateCreateFlags
-> VkPipelineViewportStateCreateFlags -> Ordering
VkPipelineViewportStateCreateFlags
-> VkPipelineViewportStateCreateFlags
-> VkPipelineViewportStateCreateFlags
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: VkPipelineViewportStateCreateFlags
-> VkPipelineViewportStateCreateFlags
-> VkPipelineViewportStateCreateFlags
$cmin :: VkPipelineViewportStateCreateFlags
-> VkPipelineViewportStateCreateFlags
-> VkPipelineViewportStateCreateFlags
max :: VkPipelineViewportStateCreateFlags
-> VkPipelineViewportStateCreateFlags
-> VkPipelineViewportStateCreateFlags
$cmax :: VkPipelineViewportStateCreateFlags
-> VkPipelineViewportStateCreateFlags
-> VkPipelineViewportStateCreateFlags
>= :: VkPipelineViewportStateCreateFlags
-> VkPipelineViewportStateCreateFlags -> Bool
$c>= :: VkPipelineViewportStateCreateFlags
-> VkPipelineViewportStateCreateFlags -> Bool
> :: VkPipelineViewportStateCreateFlags
-> VkPipelineViewportStateCreateFlags -> Bool
$c> :: VkPipelineViewportStateCreateFlags
-> VkPipelineViewportStateCreateFlags -> Bool
<= :: VkPipelineViewportStateCreateFlags
-> VkPipelineViewportStateCreateFlags -> Bool
$c<= :: VkPipelineViewportStateCreateFlags
-> VkPipelineViewportStateCreateFlags -> Bool
< :: VkPipelineViewportStateCreateFlags
-> VkPipelineViewportStateCreateFlags -> Bool
$c< :: VkPipelineViewportStateCreateFlags
-> VkPipelineViewportStateCreateFlags -> Bool
compare :: VkPipelineViewportStateCreateFlags
-> VkPipelineViewportStateCreateFlags -> Ordering
$ccompare :: VkPipelineViewportStateCreateFlags
-> VkPipelineViewportStateCreateFlags -> Ordering
Ord, Int -> VkPipelineViewportStateCreateFlags
VkPipelineViewportStateCreateFlags -> Int
VkPipelineViewportStateCreateFlags
-> [VkPipelineViewportStateCreateFlags]
VkPipelineViewportStateCreateFlags
-> VkPipelineViewportStateCreateFlags
VkPipelineViewportStateCreateFlags
-> VkPipelineViewportStateCreateFlags
-> [VkPipelineViewportStateCreateFlags]
VkPipelineViewportStateCreateFlags
-> VkPipelineViewportStateCreateFlags
-> VkPipelineViewportStateCreateFlags
-> [VkPipelineViewportStateCreateFlags]
(VkPipelineViewportStateCreateFlags
 -> VkPipelineViewportStateCreateFlags)
-> (VkPipelineViewportStateCreateFlags
    -> VkPipelineViewportStateCreateFlags)
-> (Int -> VkPipelineViewportStateCreateFlags)
-> (VkPipelineViewportStateCreateFlags -> Int)
-> (VkPipelineViewportStateCreateFlags
    -> [VkPipelineViewportStateCreateFlags])
-> (VkPipelineViewportStateCreateFlags
    -> VkPipelineViewportStateCreateFlags
    -> [VkPipelineViewportStateCreateFlags])
-> (VkPipelineViewportStateCreateFlags
    -> VkPipelineViewportStateCreateFlags
    -> [VkPipelineViewportStateCreateFlags])
-> (VkPipelineViewportStateCreateFlags
    -> VkPipelineViewportStateCreateFlags
    -> VkPipelineViewportStateCreateFlags
    -> [VkPipelineViewportStateCreateFlags])
-> Enum VkPipelineViewportStateCreateFlags
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: VkPipelineViewportStateCreateFlags
-> VkPipelineViewportStateCreateFlags
-> VkPipelineViewportStateCreateFlags
-> [VkPipelineViewportStateCreateFlags]
$cenumFromThenTo :: VkPipelineViewportStateCreateFlags
-> VkPipelineViewportStateCreateFlags
-> VkPipelineViewportStateCreateFlags
-> [VkPipelineViewportStateCreateFlags]
enumFromTo :: VkPipelineViewportStateCreateFlags
-> VkPipelineViewportStateCreateFlags
-> [VkPipelineViewportStateCreateFlags]
$cenumFromTo :: VkPipelineViewportStateCreateFlags
-> VkPipelineViewportStateCreateFlags
-> [VkPipelineViewportStateCreateFlags]
enumFromThen :: VkPipelineViewportStateCreateFlags
-> VkPipelineViewportStateCreateFlags
-> [VkPipelineViewportStateCreateFlags]
$cenumFromThen :: VkPipelineViewportStateCreateFlags
-> VkPipelineViewportStateCreateFlags
-> [VkPipelineViewportStateCreateFlags]
enumFrom :: VkPipelineViewportStateCreateFlags
-> [VkPipelineViewportStateCreateFlags]
$cenumFrom :: VkPipelineViewportStateCreateFlags
-> [VkPipelineViewportStateCreateFlags]
fromEnum :: VkPipelineViewportStateCreateFlags -> Int
$cfromEnum :: VkPipelineViewportStateCreateFlags -> Int
toEnum :: Int -> VkPipelineViewportStateCreateFlags
$ctoEnum :: Int -> VkPipelineViewportStateCreateFlags
pred :: VkPipelineViewportStateCreateFlags
-> VkPipelineViewportStateCreateFlags
$cpred :: VkPipelineViewportStateCreateFlags
-> VkPipelineViewportStateCreateFlags
succ :: VkPipelineViewportStateCreateFlags
-> VkPipelineViewportStateCreateFlags
$csucc :: VkPipelineViewportStateCreateFlags
-> VkPipelineViewportStateCreateFlags
Enum, Eq VkPipelineViewportStateCreateFlags
VkPipelineViewportStateCreateFlags
Eq VkPipelineViewportStateCreateFlags
-> (VkPipelineViewportStateCreateFlags
    -> VkPipelineViewportStateCreateFlags
    -> VkPipelineViewportStateCreateFlags)
-> (VkPipelineViewportStateCreateFlags
    -> VkPipelineViewportStateCreateFlags
    -> VkPipelineViewportStateCreateFlags)
-> (VkPipelineViewportStateCreateFlags
    -> VkPipelineViewportStateCreateFlags
    -> VkPipelineViewportStateCreateFlags)
-> (VkPipelineViewportStateCreateFlags
    -> VkPipelineViewportStateCreateFlags)
-> (VkPipelineViewportStateCreateFlags
    -> Int -> VkPipelineViewportStateCreateFlags)
-> (VkPipelineViewportStateCreateFlags
    -> Int -> VkPipelineViewportStateCreateFlags)
-> VkPipelineViewportStateCreateFlags
-> (Int -> VkPipelineViewportStateCreateFlags)
-> (VkPipelineViewportStateCreateFlags
    -> Int -> VkPipelineViewportStateCreateFlags)
-> (VkPipelineViewportStateCreateFlags
    -> Int -> VkPipelineViewportStateCreateFlags)
-> (VkPipelineViewportStateCreateFlags
    -> Int -> VkPipelineViewportStateCreateFlags)
-> (VkPipelineViewportStateCreateFlags -> Int -> Bool)
-> (VkPipelineViewportStateCreateFlags -> Maybe Int)
-> (VkPipelineViewportStateCreateFlags -> Int)
-> (VkPipelineViewportStateCreateFlags -> Bool)
-> (VkPipelineViewportStateCreateFlags
    -> Int -> VkPipelineViewportStateCreateFlags)
-> (VkPipelineViewportStateCreateFlags
    -> Int -> VkPipelineViewportStateCreateFlags)
-> (VkPipelineViewportStateCreateFlags
    -> Int -> VkPipelineViewportStateCreateFlags)
-> (VkPipelineViewportStateCreateFlags
    -> Int -> VkPipelineViewportStateCreateFlags)
-> (VkPipelineViewportStateCreateFlags
    -> Int -> VkPipelineViewportStateCreateFlags)
-> (VkPipelineViewportStateCreateFlags
    -> Int -> VkPipelineViewportStateCreateFlags)
-> (VkPipelineViewportStateCreateFlags -> Int)
-> Bits VkPipelineViewportStateCreateFlags
Int -> VkPipelineViewportStateCreateFlags
VkPipelineViewportStateCreateFlags -> Bool
VkPipelineViewportStateCreateFlags -> Int
VkPipelineViewportStateCreateFlags -> Maybe Int
VkPipelineViewportStateCreateFlags
-> VkPipelineViewportStateCreateFlags
VkPipelineViewportStateCreateFlags -> Int -> Bool
VkPipelineViewportStateCreateFlags
-> Int -> VkPipelineViewportStateCreateFlags
VkPipelineViewportStateCreateFlags
-> VkPipelineViewportStateCreateFlags
-> VkPipelineViewportStateCreateFlags
forall a.
Eq a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
popCount :: VkPipelineViewportStateCreateFlags -> Int
$cpopCount :: VkPipelineViewportStateCreateFlags -> Int
rotateR :: VkPipelineViewportStateCreateFlags
-> Int -> VkPipelineViewportStateCreateFlags
$crotateR :: VkPipelineViewportStateCreateFlags
-> Int -> VkPipelineViewportStateCreateFlags
rotateL :: VkPipelineViewportStateCreateFlags
-> Int -> VkPipelineViewportStateCreateFlags
$crotateL :: VkPipelineViewportStateCreateFlags
-> Int -> VkPipelineViewportStateCreateFlags
unsafeShiftR :: VkPipelineViewportStateCreateFlags
-> Int -> VkPipelineViewportStateCreateFlags
$cunsafeShiftR :: VkPipelineViewportStateCreateFlags
-> Int -> VkPipelineViewportStateCreateFlags
shiftR :: VkPipelineViewportStateCreateFlags
-> Int -> VkPipelineViewportStateCreateFlags
$cshiftR :: VkPipelineViewportStateCreateFlags
-> Int -> VkPipelineViewportStateCreateFlags
unsafeShiftL :: VkPipelineViewportStateCreateFlags
-> Int -> VkPipelineViewportStateCreateFlags
$cunsafeShiftL :: VkPipelineViewportStateCreateFlags
-> Int -> VkPipelineViewportStateCreateFlags
shiftL :: VkPipelineViewportStateCreateFlags
-> Int -> VkPipelineViewportStateCreateFlags
$cshiftL :: VkPipelineViewportStateCreateFlags
-> Int -> VkPipelineViewportStateCreateFlags
isSigned :: VkPipelineViewportStateCreateFlags -> Bool
$cisSigned :: VkPipelineViewportStateCreateFlags -> Bool
bitSize :: VkPipelineViewportStateCreateFlags -> Int
$cbitSize :: VkPipelineViewportStateCreateFlags -> Int
bitSizeMaybe :: VkPipelineViewportStateCreateFlags -> Maybe Int
$cbitSizeMaybe :: VkPipelineViewportStateCreateFlags -> Maybe Int
testBit :: VkPipelineViewportStateCreateFlags -> Int -> Bool
$ctestBit :: VkPipelineViewportStateCreateFlags -> Int -> Bool
complementBit :: VkPipelineViewportStateCreateFlags
-> Int -> VkPipelineViewportStateCreateFlags
$ccomplementBit :: VkPipelineViewportStateCreateFlags
-> Int -> VkPipelineViewportStateCreateFlags
clearBit :: VkPipelineViewportStateCreateFlags
-> Int -> VkPipelineViewportStateCreateFlags
$cclearBit :: VkPipelineViewportStateCreateFlags
-> Int -> VkPipelineViewportStateCreateFlags
setBit :: VkPipelineViewportStateCreateFlags
-> Int -> VkPipelineViewportStateCreateFlags
$csetBit :: VkPipelineViewportStateCreateFlags
-> Int -> VkPipelineViewportStateCreateFlags
bit :: Int -> VkPipelineViewportStateCreateFlags
$cbit :: Int -> VkPipelineViewportStateCreateFlags
zeroBits :: VkPipelineViewportStateCreateFlags
$czeroBits :: VkPipelineViewportStateCreateFlags
rotate :: VkPipelineViewportStateCreateFlags
-> Int -> VkPipelineViewportStateCreateFlags
$crotate :: VkPipelineViewportStateCreateFlags
-> Int -> VkPipelineViewportStateCreateFlags
shift :: VkPipelineViewportStateCreateFlags
-> Int -> VkPipelineViewportStateCreateFlags
$cshift :: VkPipelineViewportStateCreateFlags
-> Int -> VkPipelineViewportStateCreateFlags
complement :: VkPipelineViewportStateCreateFlags
-> VkPipelineViewportStateCreateFlags
$ccomplement :: VkPipelineViewportStateCreateFlags
-> VkPipelineViewportStateCreateFlags
xor :: VkPipelineViewportStateCreateFlags
-> VkPipelineViewportStateCreateFlags
-> VkPipelineViewportStateCreateFlags
$cxor :: VkPipelineViewportStateCreateFlags
-> VkPipelineViewportStateCreateFlags
-> VkPipelineViewportStateCreateFlags
.|. :: VkPipelineViewportStateCreateFlags
-> VkPipelineViewportStateCreateFlags
-> VkPipelineViewportStateCreateFlags
$c.|. :: VkPipelineViewportStateCreateFlags
-> VkPipelineViewportStateCreateFlags
-> VkPipelineViewportStateCreateFlags
.&. :: VkPipelineViewportStateCreateFlags
-> VkPipelineViewportStateCreateFlags
-> VkPipelineViewportStateCreateFlags
$c.&. :: VkPipelineViewportStateCreateFlags
-> VkPipelineViewportStateCreateFlags
-> VkPipelineViewportStateCreateFlags
Bits, Bits VkPipelineViewportStateCreateFlags
Bits VkPipelineViewportStateCreateFlags
-> (VkPipelineViewportStateCreateFlags -> Int)
-> (VkPipelineViewportStateCreateFlags -> Int)
-> (VkPipelineViewportStateCreateFlags -> Int)
-> FiniteBits VkPipelineViewportStateCreateFlags
VkPipelineViewportStateCreateFlags -> Int
forall b.
Bits b -> (b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
countTrailingZeros :: VkPipelineViewportStateCreateFlags -> Int
$ccountTrailingZeros :: VkPipelineViewportStateCreateFlags -> Int
countLeadingZeros :: VkPipelineViewportStateCreateFlags -> Int
$ccountLeadingZeros :: VkPipelineViewportStateCreateFlags -> Int
finiteBitSize :: VkPipelineViewportStateCreateFlags -> Int
$cfiniteBitSize :: VkPipelineViewportStateCreateFlags -> Int
FiniteBits, Ptr VkPipelineViewportStateCreateFlags
-> IO VkPipelineViewportStateCreateFlags
Ptr VkPipelineViewportStateCreateFlags
-> Int -> IO VkPipelineViewportStateCreateFlags
Ptr VkPipelineViewportStateCreateFlags
-> Int -> VkPipelineViewportStateCreateFlags -> IO ()
Ptr VkPipelineViewportStateCreateFlags
-> VkPipelineViewportStateCreateFlags -> IO ()
VkPipelineViewportStateCreateFlags -> Int
(VkPipelineViewportStateCreateFlags -> Int)
-> (VkPipelineViewportStateCreateFlags -> Int)
-> (Ptr VkPipelineViewportStateCreateFlags
    -> Int -> IO VkPipelineViewportStateCreateFlags)
-> (Ptr VkPipelineViewportStateCreateFlags
    -> Int -> VkPipelineViewportStateCreateFlags -> IO ())
-> (forall b.
    Ptr b -> Int -> IO VkPipelineViewportStateCreateFlags)
-> (forall b.
    Ptr b -> Int -> VkPipelineViewportStateCreateFlags -> IO ())
-> (Ptr VkPipelineViewportStateCreateFlags
    -> IO VkPipelineViewportStateCreateFlags)
-> (Ptr VkPipelineViewportStateCreateFlags
    -> VkPipelineViewportStateCreateFlags -> IO ())
-> Storable VkPipelineViewportStateCreateFlags
forall b. Ptr b -> Int -> IO VkPipelineViewportStateCreateFlags
forall b.
Ptr b -> Int -> VkPipelineViewportStateCreateFlags -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr VkPipelineViewportStateCreateFlags
-> VkPipelineViewportStateCreateFlags -> IO ()
$cpoke :: Ptr VkPipelineViewportStateCreateFlags
-> VkPipelineViewportStateCreateFlags -> IO ()
peek :: Ptr VkPipelineViewportStateCreateFlags
-> IO VkPipelineViewportStateCreateFlags
$cpeek :: Ptr VkPipelineViewportStateCreateFlags
-> IO VkPipelineViewportStateCreateFlags
pokeByteOff :: forall b.
Ptr b -> Int -> VkPipelineViewportStateCreateFlags -> IO ()
$cpokeByteOff :: forall b.
Ptr b -> Int -> VkPipelineViewportStateCreateFlags -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO VkPipelineViewportStateCreateFlags
$cpeekByteOff :: forall b. Ptr b -> Int -> IO VkPipelineViewportStateCreateFlags
pokeElemOff :: Ptr VkPipelineViewportStateCreateFlags
-> Int -> VkPipelineViewportStateCreateFlags -> IO ()
$cpokeElemOff :: Ptr VkPipelineViewportStateCreateFlags
-> Int -> VkPipelineViewportStateCreateFlags -> IO ()
peekElemOff :: Ptr VkPipelineViewportStateCreateFlags
-> Int -> IO VkPipelineViewportStateCreateFlags
$cpeekElemOff :: Ptr VkPipelineViewportStateCreateFlags
-> Int -> IO VkPipelineViewportStateCreateFlags
alignment :: VkPipelineViewportStateCreateFlags -> Int
$calignment :: VkPipelineViewportStateCreateFlags -> Int
sizeOf :: VkPipelineViewportStateCreateFlags -> Int
$csizeOf :: VkPipelineViewportStateCreateFlags -> Int
Storable)

instance Show VkPipelineViewportStateCreateFlags where
    {-# INLINE showsPrec #-}
    showsPrec :: Int -> VkPipelineViewportStateCreateFlags -> ShowS
showsPrec = (Int -> VkFlags -> ShowS)
-> Int -> VkPipelineViewportStateCreateFlags -> ShowS
coerce (Int -> VkFlags -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec :: Int -> VkFlags -> ShowS)

instance Read VkPipelineViewportStateCreateFlags where
    {-# INLINE readsPrec #-}
    readsPrec :: Int -> ReadS VkPipelineViewportStateCreateFlags
readsPrec = (Int -> ReadS VkFlags)
-> Int -> ReadS VkPipelineViewportStateCreateFlags
coerce (Int -> ReadS VkFlags
forall a. Read a => Int -> ReadS a
readsPrec :: Int -> ReadS VkFlags)

newtype VkPipelineViewportSwizzleStateCreateFlagsNV = VkPipelineViewportSwizzleStateCreateFlagsNV VkFlags
                                                      deriving (VkPipelineViewportSwizzleStateCreateFlagsNV
-> VkPipelineViewportSwizzleStateCreateFlagsNV -> Bool
(VkPipelineViewportSwizzleStateCreateFlagsNV
 -> VkPipelineViewportSwizzleStateCreateFlagsNV -> Bool)
-> (VkPipelineViewportSwizzleStateCreateFlagsNV
    -> VkPipelineViewportSwizzleStateCreateFlagsNV -> Bool)
-> Eq VkPipelineViewportSwizzleStateCreateFlagsNV
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VkPipelineViewportSwizzleStateCreateFlagsNV
-> VkPipelineViewportSwizzleStateCreateFlagsNV -> Bool
$c/= :: VkPipelineViewportSwizzleStateCreateFlagsNV
-> VkPipelineViewportSwizzleStateCreateFlagsNV -> Bool
== :: VkPipelineViewportSwizzleStateCreateFlagsNV
-> VkPipelineViewportSwizzleStateCreateFlagsNV -> Bool
$c== :: VkPipelineViewportSwizzleStateCreateFlagsNV
-> VkPipelineViewportSwizzleStateCreateFlagsNV -> Bool
Eq, Eq VkPipelineViewportSwizzleStateCreateFlagsNV
Eq VkPipelineViewportSwizzleStateCreateFlagsNV
-> (VkPipelineViewportSwizzleStateCreateFlagsNV
    -> VkPipelineViewportSwizzleStateCreateFlagsNV -> Ordering)
-> (VkPipelineViewportSwizzleStateCreateFlagsNV
    -> VkPipelineViewportSwizzleStateCreateFlagsNV -> Bool)
-> (VkPipelineViewportSwizzleStateCreateFlagsNV
    -> VkPipelineViewportSwizzleStateCreateFlagsNV -> Bool)
-> (VkPipelineViewportSwizzleStateCreateFlagsNV
    -> VkPipelineViewportSwizzleStateCreateFlagsNV -> Bool)
-> (VkPipelineViewportSwizzleStateCreateFlagsNV
    -> VkPipelineViewportSwizzleStateCreateFlagsNV -> Bool)
-> (VkPipelineViewportSwizzleStateCreateFlagsNV
    -> VkPipelineViewportSwizzleStateCreateFlagsNV
    -> VkPipelineViewportSwizzleStateCreateFlagsNV)
-> (VkPipelineViewportSwizzleStateCreateFlagsNV
    -> VkPipelineViewportSwizzleStateCreateFlagsNV
    -> VkPipelineViewportSwizzleStateCreateFlagsNV)
-> Ord VkPipelineViewportSwizzleStateCreateFlagsNV
VkPipelineViewportSwizzleStateCreateFlagsNV
-> VkPipelineViewportSwizzleStateCreateFlagsNV -> Bool
VkPipelineViewportSwizzleStateCreateFlagsNV
-> VkPipelineViewportSwizzleStateCreateFlagsNV -> Ordering
VkPipelineViewportSwizzleStateCreateFlagsNV
-> VkPipelineViewportSwizzleStateCreateFlagsNV
-> VkPipelineViewportSwizzleStateCreateFlagsNV
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: VkPipelineViewportSwizzleStateCreateFlagsNV
-> VkPipelineViewportSwizzleStateCreateFlagsNV
-> VkPipelineViewportSwizzleStateCreateFlagsNV
$cmin :: VkPipelineViewportSwizzleStateCreateFlagsNV
-> VkPipelineViewportSwizzleStateCreateFlagsNV
-> VkPipelineViewportSwizzleStateCreateFlagsNV
max :: VkPipelineViewportSwizzleStateCreateFlagsNV
-> VkPipelineViewportSwizzleStateCreateFlagsNV
-> VkPipelineViewportSwizzleStateCreateFlagsNV
$cmax :: VkPipelineViewportSwizzleStateCreateFlagsNV
-> VkPipelineViewportSwizzleStateCreateFlagsNV
-> VkPipelineViewportSwizzleStateCreateFlagsNV
>= :: VkPipelineViewportSwizzleStateCreateFlagsNV
-> VkPipelineViewportSwizzleStateCreateFlagsNV -> Bool
$c>= :: VkPipelineViewportSwizzleStateCreateFlagsNV
-> VkPipelineViewportSwizzleStateCreateFlagsNV -> Bool
> :: VkPipelineViewportSwizzleStateCreateFlagsNV
-> VkPipelineViewportSwizzleStateCreateFlagsNV -> Bool
$c> :: VkPipelineViewportSwizzleStateCreateFlagsNV
-> VkPipelineViewportSwizzleStateCreateFlagsNV -> Bool
<= :: VkPipelineViewportSwizzleStateCreateFlagsNV
-> VkPipelineViewportSwizzleStateCreateFlagsNV -> Bool
$c<= :: VkPipelineViewportSwizzleStateCreateFlagsNV
-> VkPipelineViewportSwizzleStateCreateFlagsNV -> Bool
< :: VkPipelineViewportSwizzleStateCreateFlagsNV
-> VkPipelineViewportSwizzleStateCreateFlagsNV -> Bool
$c< :: VkPipelineViewportSwizzleStateCreateFlagsNV
-> VkPipelineViewportSwizzleStateCreateFlagsNV -> Bool
compare :: VkPipelineViewportSwizzleStateCreateFlagsNV
-> VkPipelineViewportSwizzleStateCreateFlagsNV -> Ordering
$ccompare :: VkPipelineViewportSwizzleStateCreateFlagsNV
-> VkPipelineViewportSwizzleStateCreateFlagsNV -> Ordering
Ord, Int -> VkPipelineViewportSwizzleStateCreateFlagsNV
VkPipelineViewportSwizzleStateCreateFlagsNV -> Int
VkPipelineViewportSwizzleStateCreateFlagsNV
-> [VkPipelineViewportSwizzleStateCreateFlagsNV]
VkPipelineViewportSwizzleStateCreateFlagsNV
-> VkPipelineViewportSwizzleStateCreateFlagsNV
VkPipelineViewportSwizzleStateCreateFlagsNV
-> VkPipelineViewportSwizzleStateCreateFlagsNV
-> [VkPipelineViewportSwizzleStateCreateFlagsNV]
VkPipelineViewportSwizzleStateCreateFlagsNV
-> VkPipelineViewportSwizzleStateCreateFlagsNV
-> VkPipelineViewportSwizzleStateCreateFlagsNV
-> [VkPipelineViewportSwizzleStateCreateFlagsNV]
(VkPipelineViewportSwizzleStateCreateFlagsNV
 -> VkPipelineViewportSwizzleStateCreateFlagsNV)
-> (VkPipelineViewportSwizzleStateCreateFlagsNV
    -> VkPipelineViewportSwizzleStateCreateFlagsNV)
-> (Int -> VkPipelineViewportSwizzleStateCreateFlagsNV)
-> (VkPipelineViewportSwizzleStateCreateFlagsNV -> Int)
-> (VkPipelineViewportSwizzleStateCreateFlagsNV
    -> [VkPipelineViewportSwizzleStateCreateFlagsNV])
-> (VkPipelineViewportSwizzleStateCreateFlagsNV
    -> VkPipelineViewportSwizzleStateCreateFlagsNV
    -> [VkPipelineViewportSwizzleStateCreateFlagsNV])
-> (VkPipelineViewportSwizzleStateCreateFlagsNV
    -> VkPipelineViewportSwizzleStateCreateFlagsNV
    -> [VkPipelineViewportSwizzleStateCreateFlagsNV])
-> (VkPipelineViewportSwizzleStateCreateFlagsNV
    -> VkPipelineViewportSwizzleStateCreateFlagsNV
    -> VkPipelineViewportSwizzleStateCreateFlagsNV
    -> [VkPipelineViewportSwizzleStateCreateFlagsNV])
-> Enum VkPipelineViewportSwizzleStateCreateFlagsNV
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: VkPipelineViewportSwizzleStateCreateFlagsNV
-> VkPipelineViewportSwizzleStateCreateFlagsNV
-> VkPipelineViewportSwizzleStateCreateFlagsNV
-> [VkPipelineViewportSwizzleStateCreateFlagsNV]
$cenumFromThenTo :: VkPipelineViewportSwizzleStateCreateFlagsNV
-> VkPipelineViewportSwizzleStateCreateFlagsNV
-> VkPipelineViewportSwizzleStateCreateFlagsNV
-> [VkPipelineViewportSwizzleStateCreateFlagsNV]
enumFromTo :: VkPipelineViewportSwizzleStateCreateFlagsNV
-> VkPipelineViewportSwizzleStateCreateFlagsNV
-> [VkPipelineViewportSwizzleStateCreateFlagsNV]
$cenumFromTo :: VkPipelineViewportSwizzleStateCreateFlagsNV
-> VkPipelineViewportSwizzleStateCreateFlagsNV
-> [VkPipelineViewportSwizzleStateCreateFlagsNV]
enumFromThen :: VkPipelineViewportSwizzleStateCreateFlagsNV
-> VkPipelineViewportSwizzleStateCreateFlagsNV
-> [VkPipelineViewportSwizzleStateCreateFlagsNV]
$cenumFromThen :: VkPipelineViewportSwizzleStateCreateFlagsNV
-> VkPipelineViewportSwizzleStateCreateFlagsNV
-> [VkPipelineViewportSwizzleStateCreateFlagsNV]
enumFrom :: VkPipelineViewportSwizzleStateCreateFlagsNV
-> [VkPipelineViewportSwizzleStateCreateFlagsNV]
$cenumFrom :: VkPipelineViewportSwizzleStateCreateFlagsNV
-> [VkPipelineViewportSwizzleStateCreateFlagsNV]
fromEnum :: VkPipelineViewportSwizzleStateCreateFlagsNV -> Int
$cfromEnum :: VkPipelineViewportSwizzleStateCreateFlagsNV -> Int
toEnum :: Int -> VkPipelineViewportSwizzleStateCreateFlagsNV
$ctoEnum :: Int -> VkPipelineViewportSwizzleStateCreateFlagsNV
pred :: VkPipelineViewportSwizzleStateCreateFlagsNV
-> VkPipelineViewportSwizzleStateCreateFlagsNV
$cpred :: VkPipelineViewportSwizzleStateCreateFlagsNV
-> VkPipelineViewportSwizzleStateCreateFlagsNV
succ :: VkPipelineViewportSwizzleStateCreateFlagsNV
-> VkPipelineViewportSwizzleStateCreateFlagsNV
$csucc :: VkPipelineViewportSwizzleStateCreateFlagsNV
-> VkPipelineViewportSwizzleStateCreateFlagsNV
Enum, Eq VkPipelineViewportSwizzleStateCreateFlagsNV
VkPipelineViewportSwizzleStateCreateFlagsNV
Eq VkPipelineViewportSwizzleStateCreateFlagsNV
-> (VkPipelineViewportSwizzleStateCreateFlagsNV
    -> VkPipelineViewportSwizzleStateCreateFlagsNV
    -> VkPipelineViewportSwizzleStateCreateFlagsNV)
-> (VkPipelineViewportSwizzleStateCreateFlagsNV
    -> VkPipelineViewportSwizzleStateCreateFlagsNV
    -> VkPipelineViewportSwizzleStateCreateFlagsNV)
-> (VkPipelineViewportSwizzleStateCreateFlagsNV
    -> VkPipelineViewportSwizzleStateCreateFlagsNV
    -> VkPipelineViewportSwizzleStateCreateFlagsNV)
-> (VkPipelineViewportSwizzleStateCreateFlagsNV
    -> VkPipelineViewportSwizzleStateCreateFlagsNV)
-> (VkPipelineViewportSwizzleStateCreateFlagsNV
    -> Int -> VkPipelineViewportSwizzleStateCreateFlagsNV)
-> (VkPipelineViewportSwizzleStateCreateFlagsNV
    -> Int -> VkPipelineViewportSwizzleStateCreateFlagsNV)
-> VkPipelineViewportSwizzleStateCreateFlagsNV
-> (Int -> VkPipelineViewportSwizzleStateCreateFlagsNV)
-> (VkPipelineViewportSwizzleStateCreateFlagsNV
    -> Int -> VkPipelineViewportSwizzleStateCreateFlagsNV)
-> (VkPipelineViewportSwizzleStateCreateFlagsNV
    -> Int -> VkPipelineViewportSwizzleStateCreateFlagsNV)
-> (VkPipelineViewportSwizzleStateCreateFlagsNV
    -> Int -> VkPipelineViewportSwizzleStateCreateFlagsNV)
-> (VkPipelineViewportSwizzleStateCreateFlagsNV -> Int -> Bool)
-> (VkPipelineViewportSwizzleStateCreateFlagsNV -> Maybe Int)
-> (VkPipelineViewportSwizzleStateCreateFlagsNV -> Int)
-> (VkPipelineViewportSwizzleStateCreateFlagsNV -> Bool)
-> (VkPipelineViewportSwizzleStateCreateFlagsNV
    -> Int -> VkPipelineViewportSwizzleStateCreateFlagsNV)
-> (VkPipelineViewportSwizzleStateCreateFlagsNV
    -> Int -> VkPipelineViewportSwizzleStateCreateFlagsNV)
-> (VkPipelineViewportSwizzleStateCreateFlagsNV
    -> Int -> VkPipelineViewportSwizzleStateCreateFlagsNV)
-> (VkPipelineViewportSwizzleStateCreateFlagsNV
    -> Int -> VkPipelineViewportSwizzleStateCreateFlagsNV)
-> (VkPipelineViewportSwizzleStateCreateFlagsNV
    -> Int -> VkPipelineViewportSwizzleStateCreateFlagsNV)
-> (VkPipelineViewportSwizzleStateCreateFlagsNV
    -> Int -> VkPipelineViewportSwizzleStateCreateFlagsNV)
-> (VkPipelineViewportSwizzleStateCreateFlagsNV -> Int)
-> Bits VkPipelineViewportSwizzleStateCreateFlagsNV
Int -> VkPipelineViewportSwizzleStateCreateFlagsNV
VkPipelineViewportSwizzleStateCreateFlagsNV -> Bool
VkPipelineViewportSwizzleStateCreateFlagsNV -> Int
VkPipelineViewportSwizzleStateCreateFlagsNV -> Maybe Int
VkPipelineViewportSwizzleStateCreateFlagsNV
-> VkPipelineViewportSwizzleStateCreateFlagsNV
VkPipelineViewportSwizzleStateCreateFlagsNV -> Int -> Bool
VkPipelineViewportSwizzleStateCreateFlagsNV
-> Int -> VkPipelineViewportSwizzleStateCreateFlagsNV
VkPipelineViewportSwizzleStateCreateFlagsNV
-> VkPipelineViewportSwizzleStateCreateFlagsNV
-> VkPipelineViewportSwizzleStateCreateFlagsNV
forall a.
Eq a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
popCount :: VkPipelineViewportSwizzleStateCreateFlagsNV -> Int
$cpopCount :: VkPipelineViewportSwizzleStateCreateFlagsNV -> Int
rotateR :: VkPipelineViewportSwizzleStateCreateFlagsNV
-> Int -> VkPipelineViewportSwizzleStateCreateFlagsNV
$crotateR :: VkPipelineViewportSwizzleStateCreateFlagsNV
-> Int -> VkPipelineViewportSwizzleStateCreateFlagsNV
rotateL :: VkPipelineViewportSwizzleStateCreateFlagsNV
-> Int -> VkPipelineViewportSwizzleStateCreateFlagsNV
$crotateL :: VkPipelineViewportSwizzleStateCreateFlagsNV
-> Int -> VkPipelineViewportSwizzleStateCreateFlagsNV
unsafeShiftR :: VkPipelineViewportSwizzleStateCreateFlagsNV
-> Int -> VkPipelineViewportSwizzleStateCreateFlagsNV
$cunsafeShiftR :: VkPipelineViewportSwizzleStateCreateFlagsNV
-> Int -> VkPipelineViewportSwizzleStateCreateFlagsNV
shiftR :: VkPipelineViewportSwizzleStateCreateFlagsNV
-> Int -> VkPipelineViewportSwizzleStateCreateFlagsNV
$cshiftR :: VkPipelineViewportSwizzleStateCreateFlagsNV
-> Int -> VkPipelineViewportSwizzleStateCreateFlagsNV
unsafeShiftL :: VkPipelineViewportSwizzleStateCreateFlagsNV
-> Int -> VkPipelineViewportSwizzleStateCreateFlagsNV
$cunsafeShiftL :: VkPipelineViewportSwizzleStateCreateFlagsNV
-> Int -> VkPipelineViewportSwizzleStateCreateFlagsNV
shiftL :: VkPipelineViewportSwizzleStateCreateFlagsNV
-> Int -> VkPipelineViewportSwizzleStateCreateFlagsNV
$cshiftL :: VkPipelineViewportSwizzleStateCreateFlagsNV
-> Int -> VkPipelineViewportSwizzleStateCreateFlagsNV
isSigned :: VkPipelineViewportSwizzleStateCreateFlagsNV -> Bool
$cisSigned :: VkPipelineViewportSwizzleStateCreateFlagsNV -> Bool
bitSize :: VkPipelineViewportSwizzleStateCreateFlagsNV -> Int
$cbitSize :: VkPipelineViewportSwizzleStateCreateFlagsNV -> Int
bitSizeMaybe :: VkPipelineViewportSwizzleStateCreateFlagsNV -> Maybe Int
$cbitSizeMaybe :: VkPipelineViewportSwizzleStateCreateFlagsNV -> Maybe Int
testBit :: VkPipelineViewportSwizzleStateCreateFlagsNV -> Int -> Bool
$ctestBit :: VkPipelineViewportSwizzleStateCreateFlagsNV -> Int -> Bool
complementBit :: VkPipelineViewportSwizzleStateCreateFlagsNV
-> Int -> VkPipelineViewportSwizzleStateCreateFlagsNV
$ccomplementBit :: VkPipelineViewportSwizzleStateCreateFlagsNV
-> Int -> VkPipelineViewportSwizzleStateCreateFlagsNV
clearBit :: VkPipelineViewportSwizzleStateCreateFlagsNV
-> Int -> VkPipelineViewportSwizzleStateCreateFlagsNV
$cclearBit :: VkPipelineViewportSwizzleStateCreateFlagsNV
-> Int -> VkPipelineViewportSwizzleStateCreateFlagsNV
setBit :: VkPipelineViewportSwizzleStateCreateFlagsNV
-> Int -> VkPipelineViewportSwizzleStateCreateFlagsNV
$csetBit :: VkPipelineViewportSwizzleStateCreateFlagsNV
-> Int -> VkPipelineViewportSwizzleStateCreateFlagsNV
bit :: Int -> VkPipelineViewportSwizzleStateCreateFlagsNV
$cbit :: Int -> VkPipelineViewportSwizzleStateCreateFlagsNV
zeroBits :: VkPipelineViewportSwizzleStateCreateFlagsNV
$czeroBits :: VkPipelineViewportSwizzleStateCreateFlagsNV
rotate :: VkPipelineViewportSwizzleStateCreateFlagsNV
-> Int -> VkPipelineViewportSwizzleStateCreateFlagsNV
$crotate :: VkPipelineViewportSwizzleStateCreateFlagsNV
-> Int -> VkPipelineViewportSwizzleStateCreateFlagsNV
shift :: VkPipelineViewportSwizzleStateCreateFlagsNV
-> Int -> VkPipelineViewportSwizzleStateCreateFlagsNV
$cshift :: VkPipelineViewportSwizzleStateCreateFlagsNV
-> Int -> VkPipelineViewportSwizzleStateCreateFlagsNV
complement :: VkPipelineViewportSwizzleStateCreateFlagsNV
-> VkPipelineViewportSwizzleStateCreateFlagsNV
$ccomplement :: VkPipelineViewportSwizzleStateCreateFlagsNV
-> VkPipelineViewportSwizzleStateCreateFlagsNV
xor :: VkPipelineViewportSwizzleStateCreateFlagsNV
-> VkPipelineViewportSwizzleStateCreateFlagsNV
-> VkPipelineViewportSwizzleStateCreateFlagsNV
$cxor :: VkPipelineViewportSwizzleStateCreateFlagsNV
-> VkPipelineViewportSwizzleStateCreateFlagsNV
-> VkPipelineViewportSwizzleStateCreateFlagsNV
.|. :: VkPipelineViewportSwizzleStateCreateFlagsNV
-> VkPipelineViewportSwizzleStateCreateFlagsNV
-> VkPipelineViewportSwizzleStateCreateFlagsNV
$c.|. :: VkPipelineViewportSwizzleStateCreateFlagsNV
-> VkPipelineViewportSwizzleStateCreateFlagsNV
-> VkPipelineViewportSwizzleStateCreateFlagsNV
.&. :: VkPipelineViewportSwizzleStateCreateFlagsNV
-> VkPipelineViewportSwizzleStateCreateFlagsNV
-> VkPipelineViewportSwizzleStateCreateFlagsNV
$c.&. :: VkPipelineViewportSwizzleStateCreateFlagsNV
-> VkPipelineViewportSwizzleStateCreateFlagsNV
-> VkPipelineViewportSwizzleStateCreateFlagsNV
Bits, Bits VkPipelineViewportSwizzleStateCreateFlagsNV
Bits VkPipelineViewportSwizzleStateCreateFlagsNV
-> (VkPipelineViewportSwizzleStateCreateFlagsNV -> Int)
-> (VkPipelineViewportSwizzleStateCreateFlagsNV -> Int)
-> (VkPipelineViewportSwizzleStateCreateFlagsNV -> Int)
-> FiniteBits VkPipelineViewportSwizzleStateCreateFlagsNV
VkPipelineViewportSwizzleStateCreateFlagsNV -> Int
forall b.
Bits b -> (b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
countTrailingZeros :: VkPipelineViewportSwizzleStateCreateFlagsNV -> Int
$ccountTrailingZeros :: VkPipelineViewportSwizzleStateCreateFlagsNV -> Int
countLeadingZeros :: VkPipelineViewportSwizzleStateCreateFlagsNV -> Int
$ccountLeadingZeros :: VkPipelineViewportSwizzleStateCreateFlagsNV -> Int
finiteBitSize :: VkPipelineViewportSwizzleStateCreateFlagsNV -> Int
$cfiniteBitSize :: VkPipelineViewportSwizzleStateCreateFlagsNV -> Int
FiniteBits,
                                                                Ptr VkPipelineViewportSwizzleStateCreateFlagsNV
-> IO VkPipelineViewportSwizzleStateCreateFlagsNV
Ptr VkPipelineViewportSwizzleStateCreateFlagsNV
-> Int -> IO VkPipelineViewportSwizzleStateCreateFlagsNV
Ptr VkPipelineViewportSwizzleStateCreateFlagsNV
-> Int -> VkPipelineViewportSwizzleStateCreateFlagsNV -> IO ()
Ptr VkPipelineViewportSwizzleStateCreateFlagsNV
-> VkPipelineViewportSwizzleStateCreateFlagsNV -> IO ()
VkPipelineViewportSwizzleStateCreateFlagsNV -> Int
(VkPipelineViewportSwizzleStateCreateFlagsNV -> Int)
-> (VkPipelineViewportSwizzleStateCreateFlagsNV -> Int)
-> (Ptr VkPipelineViewportSwizzleStateCreateFlagsNV
    -> Int -> IO VkPipelineViewportSwizzleStateCreateFlagsNV)
-> (Ptr VkPipelineViewportSwizzleStateCreateFlagsNV
    -> Int -> VkPipelineViewportSwizzleStateCreateFlagsNV -> IO ())
-> (forall b.
    Ptr b -> Int -> IO VkPipelineViewportSwizzleStateCreateFlagsNV)
-> (forall b.
    Ptr b
    -> Int -> VkPipelineViewportSwizzleStateCreateFlagsNV -> IO ())
-> (Ptr VkPipelineViewportSwizzleStateCreateFlagsNV
    -> IO VkPipelineViewportSwizzleStateCreateFlagsNV)
-> (Ptr VkPipelineViewportSwizzleStateCreateFlagsNV
    -> VkPipelineViewportSwizzleStateCreateFlagsNV -> IO ())
-> Storable VkPipelineViewportSwizzleStateCreateFlagsNV
forall b.
Ptr b -> Int -> IO VkPipelineViewportSwizzleStateCreateFlagsNV
forall b.
Ptr b
-> Int -> VkPipelineViewportSwizzleStateCreateFlagsNV -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr VkPipelineViewportSwizzleStateCreateFlagsNV
-> VkPipelineViewportSwizzleStateCreateFlagsNV -> IO ()
$cpoke :: Ptr VkPipelineViewportSwizzleStateCreateFlagsNV
-> VkPipelineViewportSwizzleStateCreateFlagsNV -> IO ()
peek :: Ptr VkPipelineViewportSwizzleStateCreateFlagsNV
-> IO VkPipelineViewportSwizzleStateCreateFlagsNV
$cpeek :: Ptr VkPipelineViewportSwizzleStateCreateFlagsNV
-> IO VkPipelineViewportSwizzleStateCreateFlagsNV
pokeByteOff :: forall b.
Ptr b
-> Int -> VkPipelineViewportSwizzleStateCreateFlagsNV -> IO ()
$cpokeByteOff :: forall b.
Ptr b
-> Int -> VkPipelineViewportSwizzleStateCreateFlagsNV -> IO ()
peekByteOff :: forall b.
Ptr b -> Int -> IO VkPipelineViewportSwizzleStateCreateFlagsNV
$cpeekByteOff :: forall b.
Ptr b -> Int -> IO VkPipelineViewportSwizzleStateCreateFlagsNV
pokeElemOff :: Ptr VkPipelineViewportSwizzleStateCreateFlagsNV
-> Int -> VkPipelineViewportSwizzleStateCreateFlagsNV -> IO ()
$cpokeElemOff :: Ptr VkPipelineViewportSwizzleStateCreateFlagsNV
-> Int -> VkPipelineViewportSwizzleStateCreateFlagsNV -> IO ()
peekElemOff :: Ptr VkPipelineViewportSwizzleStateCreateFlagsNV
-> Int -> IO VkPipelineViewportSwizzleStateCreateFlagsNV
$cpeekElemOff :: Ptr VkPipelineViewportSwizzleStateCreateFlagsNV
-> Int -> IO VkPipelineViewportSwizzleStateCreateFlagsNV
alignment :: VkPipelineViewportSwizzleStateCreateFlagsNV -> Int
$calignment :: VkPipelineViewportSwizzleStateCreateFlagsNV -> Int
sizeOf :: VkPipelineViewportSwizzleStateCreateFlagsNV -> Int
$csizeOf :: VkPipelineViewportSwizzleStateCreateFlagsNV -> Int
Storable)

instance Show VkPipelineViewportSwizzleStateCreateFlagsNV where
    {-# INLINE showsPrec #-}
    showsPrec :: Int -> VkPipelineViewportSwizzleStateCreateFlagsNV -> ShowS
showsPrec = (Int -> VkFlags -> ShowS)
-> Int -> VkPipelineViewportSwizzleStateCreateFlagsNV -> ShowS
coerce (Int -> VkFlags -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec :: Int -> VkFlags -> ShowS)

instance Read VkPipelineViewportSwizzleStateCreateFlagsNV where
    {-# INLINE readsPrec #-}
    readsPrec :: Int -> ReadS VkPipelineViewportSwizzleStateCreateFlagsNV
readsPrec = (Int -> ReadS VkFlags)
-> Int -> ReadS VkPipelineViewportSwizzleStateCreateFlagsNV
coerce (Int -> ReadS VkFlags
forall a. Read a => Int -> ReadS a
readsPrec :: Int -> ReadS VkFlags)

newtype VkQueryPoolCreateFlags = VkQueryPoolCreateFlags VkFlags
                                 deriving (VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags -> Bool
(VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags -> Bool)
-> (VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags -> Bool)
-> Eq VkQueryPoolCreateFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags -> Bool
$c/= :: VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags -> Bool
== :: VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags -> Bool
$c== :: VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags -> Bool
Eq, Eq VkQueryPoolCreateFlags
Eq VkQueryPoolCreateFlags
-> (VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags -> Ordering)
-> (VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags -> Bool)
-> (VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags -> Bool)
-> (VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags -> Bool)
-> (VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags -> Bool)
-> (VkQueryPoolCreateFlags
    -> VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags)
-> (VkQueryPoolCreateFlags
    -> VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags)
-> Ord VkQueryPoolCreateFlags
VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags -> Bool
VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags -> Ordering
VkQueryPoolCreateFlags
-> VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: VkQueryPoolCreateFlags
-> VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags
$cmin :: VkQueryPoolCreateFlags
-> VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags
max :: VkQueryPoolCreateFlags
-> VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags
$cmax :: VkQueryPoolCreateFlags
-> VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags
>= :: VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags -> Bool
$c>= :: VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags -> Bool
> :: VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags -> Bool
$c> :: VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags -> Bool
<= :: VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags -> Bool
$c<= :: VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags -> Bool
< :: VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags -> Bool
$c< :: VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags -> Bool
compare :: VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags -> Ordering
$ccompare :: VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags -> Ordering
Ord, Int -> VkQueryPoolCreateFlags
VkQueryPoolCreateFlags -> Int
VkQueryPoolCreateFlags -> [VkQueryPoolCreateFlags]
VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags
VkQueryPoolCreateFlags
-> VkQueryPoolCreateFlags -> [VkQueryPoolCreateFlags]
VkQueryPoolCreateFlags
-> VkQueryPoolCreateFlags
-> VkQueryPoolCreateFlags
-> [VkQueryPoolCreateFlags]
(VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags)
-> (VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags)
-> (Int -> VkQueryPoolCreateFlags)
-> (VkQueryPoolCreateFlags -> Int)
-> (VkQueryPoolCreateFlags -> [VkQueryPoolCreateFlags])
-> (VkQueryPoolCreateFlags
    -> VkQueryPoolCreateFlags -> [VkQueryPoolCreateFlags])
-> (VkQueryPoolCreateFlags
    -> VkQueryPoolCreateFlags -> [VkQueryPoolCreateFlags])
-> (VkQueryPoolCreateFlags
    -> VkQueryPoolCreateFlags
    -> VkQueryPoolCreateFlags
    -> [VkQueryPoolCreateFlags])
-> Enum VkQueryPoolCreateFlags
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: VkQueryPoolCreateFlags
-> VkQueryPoolCreateFlags
-> VkQueryPoolCreateFlags
-> [VkQueryPoolCreateFlags]
$cenumFromThenTo :: VkQueryPoolCreateFlags
-> VkQueryPoolCreateFlags
-> VkQueryPoolCreateFlags
-> [VkQueryPoolCreateFlags]
enumFromTo :: VkQueryPoolCreateFlags
-> VkQueryPoolCreateFlags -> [VkQueryPoolCreateFlags]
$cenumFromTo :: VkQueryPoolCreateFlags
-> VkQueryPoolCreateFlags -> [VkQueryPoolCreateFlags]
enumFromThen :: VkQueryPoolCreateFlags
-> VkQueryPoolCreateFlags -> [VkQueryPoolCreateFlags]
$cenumFromThen :: VkQueryPoolCreateFlags
-> VkQueryPoolCreateFlags -> [VkQueryPoolCreateFlags]
enumFrom :: VkQueryPoolCreateFlags -> [VkQueryPoolCreateFlags]
$cenumFrom :: VkQueryPoolCreateFlags -> [VkQueryPoolCreateFlags]
fromEnum :: VkQueryPoolCreateFlags -> Int
$cfromEnum :: VkQueryPoolCreateFlags -> Int
toEnum :: Int -> VkQueryPoolCreateFlags
$ctoEnum :: Int -> VkQueryPoolCreateFlags
pred :: VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags
$cpred :: VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags
succ :: VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags
$csucc :: VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags
Enum, Eq VkQueryPoolCreateFlags
VkQueryPoolCreateFlags
Eq VkQueryPoolCreateFlags
-> (VkQueryPoolCreateFlags
    -> VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags)
-> (VkQueryPoolCreateFlags
    -> VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags)
-> (VkQueryPoolCreateFlags
    -> VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags)
-> (VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags)
-> (VkQueryPoolCreateFlags -> Int -> VkQueryPoolCreateFlags)
-> (VkQueryPoolCreateFlags -> Int -> VkQueryPoolCreateFlags)
-> VkQueryPoolCreateFlags
-> (Int -> VkQueryPoolCreateFlags)
-> (VkQueryPoolCreateFlags -> Int -> VkQueryPoolCreateFlags)
-> (VkQueryPoolCreateFlags -> Int -> VkQueryPoolCreateFlags)
-> (VkQueryPoolCreateFlags -> Int -> VkQueryPoolCreateFlags)
-> (VkQueryPoolCreateFlags -> Int -> Bool)
-> (VkQueryPoolCreateFlags -> Maybe Int)
-> (VkQueryPoolCreateFlags -> Int)
-> (VkQueryPoolCreateFlags -> Bool)
-> (VkQueryPoolCreateFlags -> Int -> VkQueryPoolCreateFlags)
-> (VkQueryPoolCreateFlags -> Int -> VkQueryPoolCreateFlags)
-> (VkQueryPoolCreateFlags -> Int -> VkQueryPoolCreateFlags)
-> (VkQueryPoolCreateFlags -> Int -> VkQueryPoolCreateFlags)
-> (VkQueryPoolCreateFlags -> Int -> VkQueryPoolCreateFlags)
-> (VkQueryPoolCreateFlags -> Int -> VkQueryPoolCreateFlags)
-> (VkQueryPoolCreateFlags -> Int)
-> Bits VkQueryPoolCreateFlags
Int -> VkQueryPoolCreateFlags
VkQueryPoolCreateFlags -> Bool
VkQueryPoolCreateFlags -> Int
VkQueryPoolCreateFlags -> Maybe Int
VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags
VkQueryPoolCreateFlags -> Int -> Bool
VkQueryPoolCreateFlags -> Int -> VkQueryPoolCreateFlags
VkQueryPoolCreateFlags
-> VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags
forall a.
Eq a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
popCount :: VkQueryPoolCreateFlags -> Int
$cpopCount :: VkQueryPoolCreateFlags -> Int
rotateR :: VkQueryPoolCreateFlags -> Int -> VkQueryPoolCreateFlags
$crotateR :: VkQueryPoolCreateFlags -> Int -> VkQueryPoolCreateFlags
rotateL :: VkQueryPoolCreateFlags -> Int -> VkQueryPoolCreateFlags
$crotateL :: VkQueryPoolCreateFlags -> Int -> VkQueryPoolCreateFlags
unsafeShiftR :: VkQueryPoolCreateFlags -> Int -> VkQueryPoolCreateFlags
$cunsafeShiftR :: VkQueryPoolCreateFlags -> Int -> VkQueryPoolCreateFlags
shiftR :: VkQueryPoolCreateFlags -> Int -> VkQueryPoolCreateFlags
$cshiftR :: VkQueryPoolCreateFlags -> Int -> VkQueryPoolCreateFlags
unsafeShiftL :: VkQueryPoolCreateFlags -> Int -> VkQueryPoolCreateFlags
$cunsafeShiftL :: VkQueryPoolCreateFlags -> Int -> VkQueryPoolCreateFlags
shiftL :: VkQueryPoolCreateFlags -> Int -> VkQueryPoolCreateFlags
$cshiftL :: VkQueryPoolCreateFlags -> Int -> VkQueryPoolCreateFlags
isSigned :: VkQueryPoolCreateFlags -> Bool
$cisSigned :: VkQueryPoolCreateFlags -> Bool
bitSize :: VkQueryPoolCreateFlags -> Int
$cbitSize :: VkQueryPoolCreateFlags -> Int
bitSizeMaybe :: VkQueryPoolCreateFlags -> Maybe Int
$cbitSizeMaybe :: VkQueryPoolCreateFlags -> Maybe Int
testBit :: VkQueryPoolCreateFlags -> Int -> Bool
$ctestBit :: VkQueryPoolCreateFlags -> Int -> Bool
complementBit :: VkQueryPoolCreateFlags -> Int -> VkQueryPoolCreateFlags
$ccomplementBit :: VkQueryPoolCreateFlags -> Int -> VkQueryPoolCreateFlags
clearBit :: VkQueryPoolCreateFlags -> Int -> VkQueryPoolCreateFlags
$cclearBit :: VkQueryPoolCreateFlags -> Int -> VkQueryPoolCreateFlags
setBit :: VkQueryPoolCreateFlags -> Int -> VkQueryPoolCreateFlags
$csetBit :: VkQueryPoolCreateFlags -> Int -> VkQueryPoolCreateFlags
bit :: Int -> VkQueryPoolCreateFlags
$cbit :: Int -> VkQueryPoolCreateFlags
zeroBits :: VkQueryPoolCreateFlags
$czeroBits :: VkQueryPoolCreateFlags
rotate :: VkQueryPoolCreateFlags -> Int -> VkQueryPoolCreateFlags
$crotate :: VkQueryPoolCreateFlags -> Int -> VkQueryPoolCreateFlags
shift :: VkQueryPoolCreateFlags -> Int -> VkQueryPoolCreateFlags
$cshift :: VkQueryPoolCreateFlags -> Int -> VkQueryPoolCreateFlags
complement :: VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags
$ccomplement :: VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags
xor :: VkQueryPoolCreateFlags
-> VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags
$cxor :: VkQueryPoolCreateFlags
-> VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags
.|. :: VkQueryPoolCreateFlags
-> VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags
$c.|. :: VkQueryPoolCreateFlags
-> VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags
.&. :: VkQueryPoolCreateFlags
-> VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags
$c.&. :: VkQueryPoolCreateFlags
-> VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags
Bits, Bits VkQueryPoolCreateFlags
Bits VkQueryPoolCreateFlags
-> (VkQueryPoolCreateFlags -> Int)
-> (VkQueryPoolCreateFlags -> Int)
-> (VkQueryPoolCreateFlags -> Int)
-> FiniteBits VkQueryPoolCreateFlags
VkQueryPoolCreateFlags -> Int
forall b.
Bits b -> (b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
countTrailingZeros :: VkQueryPoolCreateFlags -> Int
$ccountTrailingZeros :: VkQueryPoolCreateFlags -> Int
countLeadingZeros :: VkQueryPoolCreateFlags -> Int
$ccountLeadingZeros :: VkQueryPoolCreateFlags -> Int
finiteBitSize :: VkQueryPoolCreateFlags -> Int
$cfiniteBitSize :: VkQueryPoolCreateFlags -> Int
FiniteBits, Ptr VkQueryPoolCreateFlags -> IO VkQueryPoolCreateFlags
Ptr VkQueryPoolCreateFlags -> Int -> IO VkQueryPoolCreateFlags
Ptr VkQueryPoolCreateFlags
-> Int -> VkQueryPoolCreateFlags -> IO ()
Ptr VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags -> IO ()
VkQueryPoolCreateFlags -> Int
(VkQueryPoolCreateFlags -> Int)
-> (VkQueryPoolCreateFlags -> Int)
-> (Ptr VkQueryPoolCreateFlags -> Int -> IO VkQueryPoolCreateFlags)
-> (Ptr VkQueryPoolCreateFlags
    -> Int -> VkQueryPoolCreateFlags -> IO ())
-> (forall b. Ptr b -> Int -> IO VkQueryPoolCreateFlags)
-> (forall b. Ptr b -> Int -> VkQueryPoolCreateFlags -> IO ())
-> (Ptr VkQueryPoolCreateFlags -> IO VkQueryPoolCreateFlags)
-> (Ptr VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags -> IO ())
-> Storable VkQueryPoolCreateFlags
forall b. Ptr b -> Int -> IO VkQueryPoolCreateFlags
forall b. Ptr b -> Int -> VkQueryPoolCreateFlags -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags -> IO ()
$cpoke :: Ptr VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags -> IO ()
peek :: Ptr VkQueryPoolCreateFlags -> IO VkQueryPoolCreateFlags
$cpeek :: Ptr VkQueryPoolCreateFlags -> IO VkQueryPoolCreateFlags
pokeByteOff :: forall b. Ptr b -> Int -> VkQueryPoolCreateFlags -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> VkQueryPoolCreateFlags -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO VkQueryPoolCreateFlags
$cpeekByteOff :: forall b. Ptr b -> Int -> IO VkQueryPoolCreateFlags
pokeElemOff :: Ptr VkQueryPoolCreateFlags
-> Int -> VkQueryPoolCreateFlags -> IO ()
$cpokeElemOff :: Ptr VkQueryPoolCreateFlags
-> Int -> VkQueryPoolCreateFlags -> IO ()
peekElemOff :: Ptr VkQueryPoolCreateFlags -> Int -> IO VkQueryPoolCreateFlags
$cpeekElemOff :: Ptr VkQueryPoolCreateFlags -> Int -> IO VkQueryPoolCreateFlags
alignment :: VkQueryPoolCreateFlags -> Int
$calignment :: VkQueryPoolCreateFlags -> Int
sizeOf :: VkQueryPoolCreateFlags -> Int
$csizeOf :: VkQueryPoolCreateFlags -> Int
Storable)

instance Show VkQueryPoolCreateFlags where
    {-# INLINE showsPrec #-}
    showsPrec :: Int -> VkQueryPoolCreateFlags -> ShowS
showsPrec = (Int -> VkFlags -> ShowS) -> Int -> VkQueryPoolCreateFlags -> ShowS
coerce (Int -> VkFlags -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec :: Int -> VkFlags -> ShowS)

instance Read VkQueryPoolCreateFlags where
    {-# INLINE readsPrec #-}
    readsPrec :: Int -> ReadS VkQueryPoolCreateFlags
readsPrec = (Int -> ReadS VkFlags) -> Int -> ReadS VkQueryPoolCreateFlags
coerce (Int -> ReadS VkFlags
forall a. Read a => Int -> ReadS a
readsPrec :: Int -> ReadS VkFlags)

newtype VkResolveModeFlagsKHR = VkResolveModeFlagsKHR VkFlags
                                deriving (VkResolveModeFlagsKHR -> VkResolveModeFlagsKHR -> Bool
(VkResolveModeFlagsKHR -> VkResolveModeFlagsKHR -> Bool)
-> (VkResolveModeFlagsKHR -> VkResolveModeFlagsKHR -> Bool)
-> Eq VkResolveModeFlagsKHR
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VkResolveModeFlagsKHR -> VkResolveModeFlagsKHR -> Bool
$c/= :: VkResolveModeFlagsKHR -> VkResolveModeFlagsKHR -> Bool
== :: VkResolveModeFlagsKHR -> VkResolveModeFlagsKHR -> Bool
$c== :: VkResolveModeFlagsKHR -> VkResolveModeFlagsKHR -> Bool
Eq, Eq VkResolveModeFlagsKHR
Eq VkResolveModeFlagsKHR
-> (VkResolveModeFlagsKHR -> VkResolveModeFlagsKHR -> Ordering)
-> (VkResolveModeFlagsKHR -> VkResolveModeFlagsKHR -> Bool)
-> (VkResolveModeFlagsKHR -> VkResolveModeFlagsKHR -> Bool)
-> (VkResolveModeFlagsKHR -> VkResolveModeFlagsKHR -> Bool)
-> (VkResolveModeFlagsKHR -> VkResolveModeFlagsKHR -> Bool)
-> (VkResolveModeFlagsKHR
    -> VkResolveModeFlagsKHR -> VkResolveModeFlagsKHR)
-> (VkResolveModeFlagsKHR
    -> VkResolveModeFlagsKHR -> VkResolveModeFlagsKHR)
-> Ord VkResolveModeFlagsKHR
VkResolveModeFlagsKHR -> VkResolveModeFlagsKHR -> Bool
VkResolveModeFlagsKHR -> VkResolveModeFlagsKHR -> Ordering
VkResolveModeFlagsKHR
-> VkResolveModeFlagsKHR -> VkResolveModeFlagsKHR
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: VkResolveModeFlagsKHR
-> VkResolveModeFlagsKHR -> VkResolveModeFlagsKHR
$cmin :: VkResolveModeFlagsKHR
-> VkResolveModeFlagsKHR -> VkResolveModeFlagsKHR
max :: VkResolveModeFlagsKHR
-> VkResolveModeFlagsKHR -> VkResolveModeFlagsKHR
$cmax :: VkResolveModeFlagsKHR
-> VkResolveModeFlagsKHR -> VkResolveModeFlagsKHR
>= :: VkResolveModeFlagsKHR -> VkResolveModeFlagsKHR -> Bool
$c>= :: VkResolveModeFlagsKHR -> VkResolveModeFlagsKHR -> Bool
> :: VkResolveModeFlagsKHR -> VkResolveModeFlagsKHR -> Bool
$c> :: VkResolveModeFlagsKHR -> VkResolveModeFlagsKHR -> Bool
<= :: VkResolveModeFlagsKHR -> VkResolveModeFlagsKHR -> Bool
$c<= :: VkResolveModeFlagsKHR -> VkResolveModeFlagsKHR -> Bool
< :: VkResolveModeFlagsKHR -> VkResolveModeFlagsKHR -> Bool
$c< :: VkResolveModeFlagsKHR -> VkResolveModeFlagsKHR -> Bool
compare :: VkResolveModeFlagsKHR -> VkResolveModeFlagsKHR -> Ordering
$ccompare :: VkResolveModeFlagsKHR -> VkResolveModeFlagsKHR -> Ordering
Ord, Int -> VkResolveModeFlagsKHR
VkResolveModeFlagsKHR -> Int
VkResolveModeFlagsKHR -> [VkResolveModeFlagsKHR]
VkResolveModeFlagsKHR -> VkResolveModeFlagsKHR
VkResolveModeFlagsKHR
-> VkResolveModeFlagsKHR -> [VkResolveModeFlagsKHR]
VkResolveModeFlagsKHR
-> VkResolveModeFlagsKHR
-> VkResolveModeFlagsKHR
-> [VkResolveModeFlagsKHR]
(VkResolveModeFlagsKHR -> VkResolveModeFlagsKHR)
-> (VkResolveModeFlagsKHR -> VkResolveModeFlagsKHR)
-> (Int -> VkResolveModeFlagsKHR)
-> (VkResolveModeFlagsKHR -> Int)
-> (VkResolveModeFlagsKHR -> [VkResolveModeFlagsKHR])
-> (VkResolveModeFlagsKHR
    -> VkResolveModeFlagsKHR -> [VkResolveModeFlagsKHR])
-> (VkResolveModeFlagsKHR
    -> VkResolveModeFlagsKHR -> [VkResolveModeFlagsKHR])
-> (VkResolveModeFlagsKHR
    -> VkResolveModeFlagsKHR
    -> VkResolveModeFlagsKHR
    -> [VkResolveModeFlagsKHR])
-> Enum VkResolveModeFlagsKHR
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: VkResolveModeFlagsKHR
-> VkResolveModeFlagsKHR
-> VkResolveModeFlagsKHR
-> [VkResolveModeFlagsKHR]
$cenumFromThenTo :: VkResolveModeFlagsKHR
-> VkResolveModeFlagsKHR
-> VkResolveModeFlagsKHR
-> [VkResolveModeFlagsKHR]
enumFromTo :: VkResolveModeFlagsKHR
-> VkResolveModeFlagsKHR -> [VkResolveModeFlagsKHR]
$cenumFromTo :: VkResolveModeFlagsKHR
-> VkResolveModeFlagsKHR -> [VkResolveModeFlagsKHR]
enumFromThen :: VkResolveModeFlagsKHR
-> VkResolveModeFlagsKHR -> [VkResolveModeFlagsKHR]
$cenumFromThen :: VkResolveModeFlagsKHR
-> VkResolveModeFlagsKHR -> [VkResolveModeFlagsKHR]
enumFrom :: VkResolveModeFlagsKHR -> [VkResolveModeFlagsKHR]
$cenumFrom :: VkResolveModeFlagsKHR -> [VkResolveModeFlagsKHR]
fromEnum :: VkResolveModeFlagsKHR -> Int
$cfromEnum :: VkResolveModeFlagsKHR -> Int
toEnum :: Int -> VkResolveModeFlagsKHR
$ctoEnum :: Int -> VkResolveModeFlagsKHR
pred :: VkResolveModeFlagsKHR -> VkResolveModeFlagsKHR
$cpred :: VkResolveModeFlagsKHR -> VkResolveModeFlagsKHR
succ :: VkResolveModeFlagsKHR -> VkResolveModeFlagsKHR
$csucc :: VkResolveModeFlagsKHR -> VkResolveModeFlagsKHR
Enum, Eq VkResolveModeFlagsKHR
VkResolveModeFlagsKHR
Eq VkResolveModeFlagsKHR
-> (VkResolveModeFlagsKHR
    -> VkResolveModeFlagsKHR -> VkResolveModeFlagsKHR)
-> (VkResolveModeFlagsKHR
    -> VkResolveModeFlagsKHR -> VkResolveModeFlagsKHR)
-> (VkResolveModeFlagsKHR
    -> VkResolveModeFlagsKHR -> VkResolveModeFlagsKHR)
-> (VkResolveModeFlagsKHR -> VkResolveModeFlagsKHR)
-> (VkResolveModeFlagsKHR -> Int -> VkResolveModeFlagsKHR)
-> (VkResolveModeFlagsKHR -> Int -> VkResolveModeFlagsKHR)
-> VkResolveModeFlagsKHR
-> (Int -> VkResolveModeFlagsKHR)
-> (VkResolveModeFlagsKHR -> Int -> VkResolveModeFlagsKHR)
-> (VkResolveModeFlagsKHR -> Int -> VkResolveModeFlagsKHR)
-> (VkResolveModeFlagsKHR -> Int -> VkResolveModeFlagsKHR)
-> (VkResolveModeFlagsKHR -> Int -> Bool)
-> (VkResolveModeFlagsKHR -> Maybe Int)
-> (VkResolveModeFlagsKHR -> Int)
-> (VkResolveModeFlagsKHR -> Bool)
-> (VkResolveModeFlagsKHR -> Int -> VkResolveModeFlagsKHR)
-> (VkResolveModeFlagsKHR -> Int -> VkResolveModeFlagsKHR)
-> (VkResolveModeFlagsKHR -> Int -> VkResolveModeFlagsKHR)
-> (VkResolveModeFlagsKHR -> Int -> VkResolveModeFlagsKHR)
-> (VkResolveModeFlagsKHR -> Int -> VkResolveModeFlagsKHR)
-> (VkResolveModeFlagsKHR -> Int -> VkResolveModeFlagsKHR)
-> (VkResolveModeFlagsKHR -> Int)
-> Bits VkResolveModeFlagsKHR
Int -> VkResolveModeFlagsKHR
VkResolveModeFlagsKHR -> Bool
VkResolveModeFlagsKHR -> Int
VkResolveModeFlagsKHR -> Maybe Int
VkResolveModeFlagsKHR -> VkResolveModeFlagsKHR
VkResolveModeFlagsKHR -> Int -> Bool
VkResolveModeFlagsKHR -> Int -> VkResolveModeFlagsKHR
VkResolveModeFlagsKHR
-> VkResolveModeFlagsKHR -> VkResolveModeFlagsKHR
forall a.
Eq a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
popCount :: VkResolveModeFlagsKHR -> Int
$cpopCount :: VkResolveModeFlagsKHR -> Int
rotateR :: VkResolveModeFlagsKHR -> Int -> VkResolveModeFlagsKHR
$crotateR :: VkResolveModeFlagsKHR -> Int -> VkResolveModeFlagsKHR
rotateL :: VkResolveModeFlagsKHR -> Int -> VkResolveModeFlagsKHR
$crotateL :: VkResolveModeFlagsKHR -> Int -> VkResolveModeFlagsKHR
unsafeShiftR :: VkResolveModeFlagsKHR -> Int -> VkResolveModeFlagsKHR
$cunsafeShiftR :: VkResolveModeFlagsKHR -> Int -> VkResolveModeFlagsKHR
shiftR :: VkResolveModeFlagsKHR -> Int -> VkResolveModeFlagsKHR
$cshiftR :: VkResolveModeFlagsKHR -> Int -> VkResolveModeFlagsKHR
unsafeShiftL :: VkResolveModeFlagsKHR -> Int -> VkResolveModeFlagsKHR
$cunsafeShiftL :: VkResolveModeFlagsKHR -> Int -> VkResolveModeFlagsKHR
shiftL :: VkResolveModeFlagsKHR -> Int -> VkResolveModeFlagsKHR
$cshiftL :: VkResolveModeFlagsKHR -> Int -> VkResolveModeFlagsKHR
isSigned :: VkResolveModeFlagsKHR -> Bool
$cisSigned :: VkResolveModeFlagsKHR -> Bool
bitSize :: VkResolveModeFlagsKHR -> Int
$cbitSize :: VkResolveModeFlagsKHR -> Int
bitSizeMaybe :: VkResolveModeFlagsKHR -> Maybe Int
$cbitSizeMaybe :: VkResolveModeFlagsKHR -> Maybe Int
testBit :: VkResolveModeFlagsKHR -> Int -> Bool
$ctestBit :: VkResolveModeFlagsKHR -> Int -> Bool
complementBit :: VkResolveModeFlagsKHR -> Int -> VkResolveModeFlagsKHR
$ccomplementBit :: VkResolveModeFlagsKHR -> Int -> VkResolveModeFlagsKHR
clearBit :: VkResolveModeFlagsKHR -> Int -> VkResolveModeFlagsKHR
$cclearBit :: VkResolveModeFlagsKHR -> Int -> VkResolveModeFlagsKHR
setBit :: VkResolveModeFlagsKHR -> Int -> VkResolveModeFlagsKHR
$csetBit :: VkResolveModeFlagsKHR -> Int -> VkResolveModeFlagsKHR
bit :: Int -> VkResolveModeFlagsKHR
$cbit :: Int -> VkResolveModeFlagsKHR
zeroBits :: VkResolveModeFlagsKHR
$czeroBits :: VkResolveModeFlagsKHR
rotate :: VkResolveModeFlagsKHR -> Int -> VkResolveModeFlagsKHR
$crotate :: VkResolveModeFlagsKHR -> Int -> VkResolveModeFlagsKHR
shift :: VkResolveModeFlagsKHR -> Int -> VkResolveModeFlagsKHR
$cshift :: VkResolveModeFlagsKHR -> Int -> VkResolveModeFlagsKHR
complement :: VkResolveModeFlagsKHR -> VkResolveModeFlagsKHR
$ccomplement :: VkResolveModeFlagsKHR -> VkResolveModeFlagsKHR
xor :: VkResolveModeFlagsKHR
-> VkResolveModeFlagsKHR -> VkResolveModeFlagsKHR
$cxor :: VkResolveModeFlagsKHR
-> VkResolveModeFlagsKHR -> VkResolveModeFlagsKHR
.|. :: VkResolveModeFlagsKHR
-> VkResolveModeFlagsKHR -> VkResolveModeFlagsKHR
$c.|. :: VkResolveModeFlagsKHR
-> VkResolveModeFlagsKHR -> VkResolveModeFlagsKHR
.&. :: VkResolveModeFlagsKHR
-> VkResolveModeFlagsKHR -> VkResolveModeFlagsKHR
$c.&. :: VkResolveModeFlagsKHR
-> VkResolveModeFlagsKHR -> VkResolveModeFlagsKHR
Bits, Bits VkResolveModeFlagsKHR
Bits VkResolveModeFlagsKHR
-> (VkResolveModeFlagsKHR -> Int)
-> (VkResolveModeFlagsKHR -> Int)
-> (VkResolveModeFlagsKHR -> Int)
-> FiniteBits VkResolveModeFlagsKHR
VkResolveModeFlagsKHR -> Int
forall b.
Bits b -> (b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
countTrailingZeros :: VkResolveModeFlagsKHR -> Int
$ccountTrailingZeros :: VkResolveModeFlagsKHR -> Int
countLeadingZeros :: VkResolveModeFlagsKHR -> Int
$ccountLeadingZeros :: VkResolveModeFlagsKHR -> Int
finiteBitSize :: VkResolveModeFlagsKHR -> Int
$cfiniteBitSize :: VkResolveModeFlagsKHR -> Int
FiniteBits, Ptr VkResolveModeFlagsKHR -> IO VkResolveModeFlagsKHR
Ptr VkResolveModeFlagsKHR -> Int -> IO VkResolveModeFlagsKHR
Ptr VkResolveModeFlagsKHR -> Int -> VkResolveModeFlagsKHR -> IO ()
Ptr VkResolveModeFlagsKHR -> VkResolveModeFlagsKHR -> IO ()
VkResolveModeFlagsKHR -> Int
(VkResolveModeFlagsKHR -> Int)
-> (VkResolveModeFlagsKHR -> Int)
-> (Ptr VkResolveModeFlagsKHR -> Int -> IO VkResolveModeFlagsKHR)
-> (Ptr VkResolveModeFlagsKHR
    -> Int -> VkResolveModeFlagsKHR -> IO ())
-> (forall b. Ptr b -> Int -> IO VkResolveModeFlagsKHR)
-> (forall b. Ptr b -> Int -> VkResolveModeFlagsKHR -> IO ())
-> (Ptr VkResolveModeFlagsKHR -> IO VkResolveModeFlagsKHR)
-> (Ptr VkResolveModeFlagsKHR -> VkResolveModeFlagsKHR -> IO ())
-> Storable VkResolveModeFlagsKHR
forall b. Ptr b -> Int -> IO VkResolveModeFlagsKHR
forall b. Ptr b -> Int -> VkResolveModeFlagsKHR -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr VkResolveModeFlagsKHR -> VkResolveModeFlagsKHR -> IO ()
$cpoke :: Ptr VkResolveModeFlagsKHR -> VkResolveModeFlagsKHR -> IO ()
peek :: Ptr VkResolveModeFlagsKHR -> IO VkResolveModeFlagsKHR
$cpeek :: Ptr VkResolveModeFlagsKHR -> IO VkResolveModeFlagsKHR
pokeByteOff :: forall b. Ptr b -> Int -> VkResolveModeFlagsKHR -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> VkResolveModeFlagsKHR -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO VkResolveModeFlagsKHR
$cpeekByteOff :: forall b. Ptr b -> Int -> IO VkResolveModeFlagsKHR
pokeElemOff :: Ptr VkResolveModeFlagsKHR -> Int -> VkResolveModeFlagsKHR -> IO ()
$cpokeElemOff :: Ptr VkResolveModeFlagsKHR -> Int -> VkResolveModeFlagsKHR -> IO ()
peekElemOff :: Ptr VkResolveModeFlagsKHR -> Int -> IO VkResolveModeFlagsKHR
$cpeekElemOff :: Ptr VkResolveModeFlagsKHR -> Int -> IO VkResolveModeFlagsKHR
alignment :: VkResolveModeFlagsKHR -> Int
$calignment :: VkResolveModeFlagsKHR -> Int
sizeOf :: VkResolveModeFlagsKHR -> Int
$csizeOf :: VkResolveModeFlagsKHR -> Int
Storable)

instance Show VkResolveModeFlagsKHR where
    {-# INLINE showsPrec #-}
    showsPrec :: Int -> VkResolveModeFlagsKHR -> ShowS
showsPrec = (Int -> VkFlags -> ShowS) -> Int -> VkResolveModeFlagsKHR -> ShowS
coerce (Int -> VkFlags -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec :: Int -> VkFlags -> ShowS)

instance Read VkResolveModeFlagsKHR where
    {-# INLINE readsPrec #-}
    readsPrec :: Int -> ReadS VkResolveModeFlagsKHR
readsPrec = (Int -> ReadS VkFlags) -> Int -> ReadS VkResolveModeFlagsKHR
coerce (Int -> ReadS VkFlags
forall a. Read a => Int -> ReadS a
readsPrec :: Int -> ReadS VkFlags)

newtype VkSemaphoreCreateFlags = VkSemaphoreCreateFlags VkFlags
                                 deriving (VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags -> Bool
(VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags -> Bool)
-> (VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags -> Bool)
-> Eq VkSemaphoreCreateFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags -> Bool
$c/= :: VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags -> Bool
== :: VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags -> Bool
$c== :: VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags -> Bool
Eq, Eq VkSemaphoreCreateFlags
Eq VkSemaphoreCreateFlags
-> (VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags -> Ordering)
-> (VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags -> Bool)
-> (VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags -> Bool)
-> (VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags -> Bool)
-> (VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags -> Bool)
-> (VkSemaphoreCreateFlags
    -> VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags)
-> (VkSemaphoreCreateFlags
    -> VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags)
-> Ord VkSemaphoreCreateFlags
VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags -> Bool
VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags -> Ordering
VkSemaphoreCreateFlags
-> VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: VkSemaphoreCreateFlags
-> VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags
$cmin :: VkSemaphoreCreateFlags
-> VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags
max :: VkSemaphoreCreateFlags
-> VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags
$cmax :: VkSemaphoreCreateFlags
-> VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags
>= :: VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags -> Bool
$c>= :: VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags -> Bool
> :: VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags -> Bool
$c> :: VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags -> Bool
<= :: VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags -> Bool
$c<= :: VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags -> Bool
< :: VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags -> Bool
$c< :: VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags -> Bool
compare :: VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags -> Ordering
$ccompare :: VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags -> Ordering
Ord, Int -> VkSemaphoreCreateFlags
VkSemaphoreCreateFlags -> Int
VkSemaphoreCreateFlags -> [VkSemaphoreCreateFlags]
VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags
VkSemaphoreCreateFlags
-> VkSemaphoreCreateFlags -> [VkSemaphoreCreateFlags]
VkSemaphoreCreateFlags
-> VkSemaphoreCreateFlags
-> VkSemaphoreCreateFlags
-> [VkSemaphoreCreateFlags]
(VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags)
-> (VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags)
-> (Int -> VkSemaphoreCreateFlags)
-> (VkSemaphoreCreateFlags -> Int)
-> (VkSemaphoreCreateFlags -> [VkSemaphoreCreateFlags])
-> (VkSemaphoreCreateFlags
    -> VkSemaphoreCreateFlags -> [VkSemaphoreCreateFlags])
-> (VkSemaphoreCreateFlags
    -> VkSemaphoreCreateFlags -> [VkSemaphoreCreateFlags])
-> (VkSemaphoreCreateFlags
    -> VkSemaphoreCreateFlags
    -> VkSemaphoreCreateFlags
    -> [VkSemaphoreCreateFlags])
-> Enum VkSemaphoreCreateFlags
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: VkSemaphoreCreateFlags
-> VkSemaphoreCreateFlags
-> VkSemaphoreCreateFlags
-> [VkSemaphoreCreateFlags]
$cenumFromThenTo :: VkSemaphoreCreateFlags
-> VkSemaphoreCreateFlags
-> VkSemaphoreCreateFlags
-> [VkSemaphoreCreateFlags]
enumFromTo :: VkSemaphoreCreateFlags
-> VkSemaphoreCreateFlags -> [VkSemaphoreCreateFlags]
$cenumFromTo :: VkSemaphoreCreateFlags
-> VkSemaphoreCreateFlags -> [VkSemaphoreCreateFlags]
enumFromThen :: VkSemaphoreCreateFlags
-> VkSemaphoreCreateFlags -> [VkSemaphoreCreateFlags]
$cenumFromThen :: VkSemaphoreCreateFlags
-> VkSemaphoreCreateFlags -> [VkSemaphoreCreateFlags]
enumFrom :: VkSemaphoreCreateFlags -> [VkSemaphoreCreateFlags]
$cenumFrom :: VkSemaphoreCreateFlags -> [VkSemaphoreCreateFlags]
fromEnum :: VkSemaphoreCreateFlags -> Int
$cfromEnum :: VkSemaphoreCreateFlags -> Int
toEnum :: Int -> VkSemaphoreCreateFlags
$ctoEnum :: Int -> VkSemaphoreCreateFlags
pred :: VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags
$cpred :: VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags
succ :: VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags
$csucc :: VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags
Enum, Eq VkSemaphoreCreateFlags
VkSemaphoreCreateFlags
Eq VkSemaphoreCreateFlags
-> (VkSemaphoreCreateFlags
    -> VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags)
-> (VkSemaphoreCreateFlags
    -> VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags)
-> (VkSemaphoreCreateFlags
    -> VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags)
-> (VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags)
-> (VkSemaphoreCreateFlags -> Int -> VkSemaphoreCreateFlags)
-> (VkSemaphoreCreateFlags -> Int -> VkSemaphoreCreateFlags)
-> VkSemaphoreCreateFlags
-> (Int -> VkSemaphoreCreateFlags)
-> (VkSemaphoreCreateFlags -> Int -> VkSemaphoreCreateFlags)
-> (VkSemaphoreCreateFlags -> Int -> VkSemaphoreCreateFlags)
-> (VkSemaphoreCreateFlags -> Int -> VkSemaphoreCreateFlags)
-> (VkSemaphoreCreateFlags -> Int -> Bool)
-> (VkSemaphoreCreateFlags -> Maybe Int)
-> (VkSemaphoreCreateFlags -> Int)
-> (VkSemaphoreCreateFlags -> Bool)
-> (VkSemaphoreCreateFlags -> Int -> VkSemaphoreCreateFlags)
-> (VkSemaphoreCreateFlags -> Int -> VkSemaphoreCreateFlags)
-> (VkSemaphoreCreateFlags -> Int -> VkSemaphoreCreateFlags)
-> (VkSemaphoreCreateFlags -> Int -> VkSemaphoreCreateFlags)
-> (VkSemaphoreCreateFlags -> Int -> VkSemaphoreCreateFlags)
-> (VkSemaphoreCreateFlags -> Int -> VkSemaphoreCreateFlags)
-> (VkSemaphoreCreateFlags -> Int)
-> Bits VkSemaphoreCreateFlags
Int -> VkSemaphoreCreateFlags
VkSemaphoreCreateFlags -> Bool
VkSemaphoreCreateFlags -> Int
VkSemaphoreCreateFlags -> Maybe Int
VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags
VkSemaphoreCreateFlags -> Int -> Bool
VkSemaphoreCreateFlags -> Int -> VkSemaphoreCreateFlags
VkSemaphoreCreateFlags
-> VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags
forall a.
Eq a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
popCount :: VkSemaphoreCreateFlags -> Int
$cpopCount :: VkSemaphoreCreateFlags -> Int
rotateR :: VkSemaphoreCreateFlags -> Int -> VkSemaphoreCreateFlags
$crotateR :: VkSemaphoreCreateFlags -> Int -> VkSemaphoreCreateFlags
rotateL :: VkSemaphoreCreateFlags -> Int -> VkSemaphoreCreateFlags
$crotateL :: VkSemaphoreCreateFlags -> Int -> VkSemaphoreCreateFlags
unsafeShiftR :: VkSemaphoreCreateFlags -> Int -> VkSemaphoreCreateFlags
$cunsafeShiftR :: VkSemaphoreCreateFlags -> Int -> VkSemaphoreCreateFlags
shiftR :: VkSemaphoreCreateFlags -> Int -> VkSemaphoreCreateFlags
$cshiftR :: VkSemaphoreCreateFlags -> Int -> VkSemaphoreCreateFlags
unsafeShiftL :: VkSemaphoreCreateFlags -> Int -> VkSemaphoreCreateFlags
$cunsafeShiftL :: VkSemaphoreCreateFlags -> Int -> VkSemaphoreCreateFlags
shiftL :: VkSemaphoreCreateFlags -> Int -> VkSemaphoreCreateFlags
$cshiftL :: VkSemaphoreCreateFlags -> Int -> VkSemaphoreCreateFlags
isSigned :: VkSemaphoreCreateFlags -> Bool
$cisSigned :: VkSemaphoreCreateFlags -> Bool
bitSize :: VkSemaphoreCreateFlags -> Int
$cbitSize :: VkSemaphoreCreateFlags -> Int
bitSizeMaybe :: VkSemaphoreCreateFlags -> Maybe Int
$cbitSizeMaybe :: VkSemaphoreCreateFlags -> Maybe Int
testBit :: VkSemaphoreCreateFlags -> Int -> Bool
$ctestBit :: VkSemaphoreCreateFlags -> Int -> Bool
complementBit :: VkSemaphoreCreateFlags -> Int -> VkSemaphoreCreateFlags
$ccomplementBit :: VkSemaphoreCreateFlags -> Int -> VkSemaphoreCreateFlags
clearBit :: VkSemaphoreCreateFlags -> Int -> VkSemaphoreCreateFlags
$cclearBit :: VkSemaphoreCreateFlags -> Int -> VkSemaphoreCreateFlags
setBit :: VkSemaphoreCreateFlags -> Int -> VkSemaphoreCreateFlags
$csetBit :: VkSemaphoreCreateFlags -> Int -> VkSemaphoreCreateFlags
bit :: Int -> VkSemaphoreCreateFlags
$cbit :: Int -> VkSemaphoreCreateFlags
zeroBits :: VkSemaphoreCreateFlags
$czeroBits :: VkSemaphoreCreateFlags
rotate :: VkSemaphoreCreateFlags -> Int -> VkSemaphoreCreateFlags
$crotate :: VkSemaphoreCreateFlags -> Int -> VkSemaphoreCreateFlags
shift :: VkSemaphoreCreateFlags -> Int -> VkSemaphoreCreateFlags
$cshift :: VkSemaphoreCreateFlags -> Int -> VkSemaphoreCreateFlags
complement :: VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags
$ccomplement :: VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags
xor :: VkSemaphoreCreateFlags
-> VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags
$cxor :: VkSemaphoreCreateFlags
-> VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags
.|. :: VkSemaphoreCreateFlags
-> VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags
$c.|. :: VkSemaphoreCreateFlags
-> VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags
.&. :: VkSemaphoreCreateFlags
-> VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags
$c.&. :: VkSemaphoreCreateFlags
-> VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags
Bits, Bits VkSemaphoreCreateFlags
Bits VkSemaphoreCreateFlags
-> (VkSemaphoreCreateFlags -> Int)
-> (VkSemaphoreCreateFlags -> Int)
-> (VkSemaphoreCreateFlags -> Int)
-> FiniteBits VkSemaphoreCreateFlags
VkSemaphoreCreateFlags -> Int
forall b.
Bits b -> (b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
countTrailingZeros :: VkSemaphoreCreateFlags -> Int
$ccountTrailingZeros :: VkSemaphoreCreateFlags -> Int
countLeadingZeros :: VkSemaphoreCreateFlags -> Int
$ccountLeadingZeros :: VkSemaphoreCreateFlags -> Int
finiteBitSize :: VkSemaphoreCreateFlags -> Int
$cfiniteBitSize :: VkSemaphoreCreateFlags -> Int
FiniteBits, Ptr VkSemaphoreCreateFlags -> IO VkSemaphoreCreateFlags
Ptr VkSemaphoreCreateFlags -> Int -> IO VkSemaphoreCreateFlags
Ptr VkSemaphoreCreateFlags
-> Int -> VkSemaphoreCreateFlags -> IO ()
Ptr VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags -> IO ()
VkSemaphoreCreateFlags -> Int
(VkSemaphoreCreateFlags -> Int)
-> (VkSemaphoreCreateFlags -> Int)
-> (Ptr VkSemaphoreCreateFlags -> Int -> IO VkSemaphoreCreateFlags)
-> (Ptr VkSemaphoreCreateFlags
    -> Int -> VkSemaphoreCreateFlags -> IO ())
-> (forall b. Ptr b -> Int -> IO VkSemaphoreCreateFlags)
-> (forall b. Ptr b -> Int -> VkSemaphoreCreateFlags -> IO ())
-> (Ptr VkSemaphoreCreateFlags -> IO VkSemaphoreCreateFlags)
-> (Ptr VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags -> IO ())
-> Storable VkSemaphoreCreateFlags
forall b. Ptr b -> Int -> IO VkSemaphoreCreateFlags
forall b. Ptr b -> Int -> VkSemaphoreCreateFlags -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags -> IO ()
$cpoke :: Ptr VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags -> IO ()
peek :: Ptr VkSemaphoreCreateFlags -> IO VkSemaphoreCreateFlags
$cpeek :: Ptr VkSemaphoreCreateFlags -> IO VkSemaphoreCreateFlags
pokeByteOff :: forall b. Ptr b -> Int -> VkSemaphoreCreateFlags -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> VkSemaphoreCreateFlags -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO VkSemaphoreCreateFlags
$cpeekByteOff :: forall b. Ptr b -> Int -> IO VkSemaphoreCreateFlags
pokeElemOff :: Ptr VkSemaphoreCreateFlags
-> Int -> VkSemaphoreCreateFlags -> IO ()
$cpokeElemOff :: Ptr VkSemaphoreCreateFlags
-> Int -> VkSemaphoreCreateFlags -> IO ()
peekElemOff :: Ptr VkSemaphoreCreateFlags -> Int -> IO VkSemaphoreCreateFlags
$cpeekElemOff :: Ptr VkSemaphoreCreateFlags -> Int -> IO VkSemaphoreCreateFlags
alignment :: VkSemaphoreCreateFlags -> Int
$calignment :: VkSemaphoreCreateFlags -> Int
sizeOf :: VkSemaphoreCreateFlags -> Int
$csizeOf :: VkSemaphoreCreateFlags -> Int
Storable)

instance Show VkSemaphoreCreateFlags where
    {-# INLINE showsPrec #-}
    showsPrec :: Int -> VkSemaphoreCreateFlags -> ShowS
showsPrec = (Int -> VkFlags -> ShowS) -> Int -> VkSemaphoreCreateFlags -> ShowS
coerce (Int -> VkFlags -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec :: Int -> VkFlags -> ShowS)

instance Read VkSemaphoreCreateFlags where
    {-# INLINE readsPrec #-}
    readsPrec :: Int -> ReadS VkSemaphoreCreateFlags
readsPrec = (Int -> ReadS VkFlags) -> Int -> ReadS VkSemaphoreCreateFlags
coerce (Int -> ReadS VkFlags
forall a. Read a => Int -> ReadS a
readsPrec :: Int -> ReadS VkFlags)

newtype VkSemaphoreImportFlagsKHR = VkSemaphoreImportFlagsKHR VkFlags
                                    deriving (VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR -> Bool
(VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR -> Bool)
-> (VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR -> Bool)
-> Eq VkSemaphoreImportFlagsKHR
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR -> Bool
$c/= :: VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR -> Bool
== :: VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR -> Bool
$c== :: VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR -> Bool
Eq, Eq VkSemaphoreImportFlagsKHR
Eq VkSemaphoreImportFlagsKHR
-> (VkSemaphoreImportFlagsKHR
    -> VkSemaphoreImportFlagsKHR -> Ordering)
-> (VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR -> Bool)
-> (VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR -> Bool)
-> (VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR -> Bool)
-> (VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR -> Bool)
-> (VkSemaphoreImportFlagsKHR
    -> VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR)
-> (VkSemaphoreImportFlagsKHR
    -> VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR)
-> Ord VkSemaphoreImportFlagsKHR
VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR -> Bool
VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR -> Ordering
VkSemaphoreImportFlagsKHR
-> VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: VkSemaphoreImportFlagsKHR
-> VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR
$cmin :: VkSemaphoreImportFlagsKHR
-> VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR
max :: VkSemaphoreImportFlagsKHR
-> VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR
$cmax :: VkSemaphoreImportFlagsKHR
-> VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR
>= :: VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR -> Bool
$c>= :: VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR -> Bool
> :: VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR -> Bool
$c> :: VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR -> Bool
<= :: VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR -> Bool
$c<= :: VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR -> Bool
< :: VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR -> Bool
$c< :: VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR -> Bool
compare :: VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR -> Ordering
$ccompare :: VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR -> Ordering
Ord, Int -> VkSemaphoreImportFlagsKHR
VkSemaphoreImportFlagsKHR -> Int
VkSemaphoreImportFlagsKHR -> [VkSemaphoreImportFlagsKHR]
VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR
VkSemaphoreImportFlagsKHR
-> VkSemaphoreImportFlagsKHR -> [VkSemaphoreImportFlagsKHR]
VkSemaphoreImportFlagsKHR
-> VkSemaphoreImportFlagsKHR
-> VkSemaphoreImportFlagsKHR
-> [VkSemaphoreImportFlagsKHR]
(VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR)
-> (VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR)
-> (Int -> VkSemaphoreImportFlagsKHR)
-> (VkSemaphoreImportFlagsKHR -> Int)
-> (VkSemaphoreImportFlagsKHR -> [VkSemaphoreImportFlagsKHR])
-> (VkSemaphoreImportFlagsKHR
    -> VkSemaphoreImportFlagsKHR -> [VkSemaphoreImportFlagsKHR])
-> (VkSemaphoreImportFlagsKHR
    -> VkSemaphoreImportFlagsKHR -> [VkSemaphoreImportFlagsKHR])
-> (VkSemaphoreImportFlagsKHR
    -> VkSemaphoreImportFlagsKHR
    -> VkSemaphoreImportFlagsKHR
    -> [VkSemaphoreImportFlagsKHR])
-> Enum VkSemaphoreImportFlagsKHR
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: VkSemaphoreImportFlagsKHR
-> VkSemaphoreImportFlagsKHR
-> VkSemaphoreImportFlagsKHR
-> [VkSemaphoreImportFlagsKHR]
$cenumFromThenTo :: VkSemaphoreImportFlagsKHR
-> VkSemaphoreImportFlagsKHR
-> VkSemaphoreImportFlagsKHR
-> [VkSemaphoreImportFlagsKHR]
enumFromTo :: VkSemaphoreImportFlagsKHR
-> VkSemaphoreImportFlagsKHR -> [VkSemaphoreImportFlagsKHR]
$cenumFromTo :: VkSemaphoreImportFlagsKHR
-> VkSemaphoreImportFlagsKHR -> [VkSemaphoreImportFlagsKHR]
enumFromThen :: VkSemaphoreImportFlagsKHR
-> VkSemaphoreImportFlagsKHR -> [VkSemaphoreImportFlagsKHR]
$cenumFromThen :: VkSemaphoreImportFlagsKHR
-> VkSemaphoreImportFlagsKHR -> [VkSemaphoreImportFlagsKHR]
enumFrom :: VkSemaphoreImportFlagsKHR -> [VkSemaphoreImportFlagsKHR]
$cenumFrom :: VkSemaphoreImportFlagsKHR -> [VkSemaphoreImportFlagsKHR]
fromEnum :: VkSemaphoreImportFlagsKHR -> Int
$cfromEnum :: VkSemaphoreImportFlagsKHR -> Int
toEnum :: Int -> VkSemaphoreImportFlagsKHR
$ctoEnum :: Int -> VkSemaphoreImportFlagsKHR
pred :: VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR
$cpred :: VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR
succ :: VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR
$csucc :: VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR
Enum, Eq VkSemaphoreImportFlagsKHR
VkSemaphoreImportFlagsKHR
Eq VkSemaphoreImportFlagsKHR
-> (VkSemaphoreImportFlagsKHR
    -> VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR)
-> (VkSemaphoreImportFlagsKHR
    -> VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR)
-> (VkSemaphoreImportFlagsKHR
    -> VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR)
-> (VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR)
-> (VkSemaphoreImportFlagsKHR -> Int -> VkSemaphoreImportFlagsKHR)
-> (VkSemaphoreImportFlagsKHR -> Int -> VkSemaphoreImportFlagsKHR)
-> VkSemaphoreImportFlagsKHR
-> (Int -> VkSemaphoreImportFlagsKHR)
-> (VkSemaphoreImportFlagsKHR -> Int -> VkSemaphoreImportFlagsKHR)
-> (VkSemaphoreImportFlagsKHR -> Int -> VkSemaphoreImportFlagsKHR)
-> (VkSemaphoreImportFlagsKHR -> Int -> VkSemaphoreImportFlagsKHR)
-> (VkSemaphoreImportFlagsKHR -> Int -> Bool)
-> (VkSemaphoreImportFlagsKHR -> Maybe Int)
-> (VkSemaphoreImportFlagsKHR -> Int)
-> (VkSemaphoreImportFlagsKHR -> Bool)
-> (VkSemaphoreImportFlagsKHR -> Int -> VkSemaphoreImportFlagsKHR)
-> (VkSemaphoreImportFlagsKHR -> Int -> VkSemaphoreImportFlagsKHR)
-> (VkSemaphoreImportFlagsKHR -> Int -> VkSemaphoreImportFlagsKHR)
-> (VkSemaphoreImportFlagsKHR -> Int -> VkSemaphoreImportFlagsKHR)
-> (VkSemaphoreImportFlagsKHR -> Int -> VkSemaphoreImportFlagsKHR)
-> (VkSemaphoreImportFlagsKHR -> Int -> VkSemaphoreImportFlagsKHR)
-> (VkSemaphoreImportFlagsKHR -> Int)
-> Bits VkSemaphoreImportFlagsKHR
Int -> VkSemaphoreImportFlagsKHR
VkSemaphoreImportFlagsKHR -> Bool
VkSemaphoreImportFlagsKHR -> Int
VkSemaphoreImportFlagsKHR -> Maybe Int
VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR
VkSemaphoreImportFlagsKHR -> Int -> Bool
VkSemaphoreImportFlagsKHR -> Int -> VkSemaphoreImportFlagsKHR
VkSemaphoreImportFlagsKHR
-> VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR
forall a.
Eq a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
popCount :: VkSemaphoreImportFlagsKHR -> Int
$cpopCount :: VkSemaphoreImportFlagsKHR -> Int
rotateR :: VkSemaphoreImportFlagsKHR -> Int -> VkSemaphoreImportFlagsKHR
$crotateR :: VkSemaphoreImportFlagsKHR -> Int -> VkSemaphoreImportFlagsKHR
rotateL :: VkSemaphoreImportFlagsKHR -> Int -> VkSemaphoreImportFlagsKHR
$crotateL :: VkSemaphoreImportFlagsKHR -> Int -> VkSemaphoreImportFlagsKHR
unsafeShiftR :: VkSemaphoreImportFlagsKHR -> Int -> VkSemaphoreImportFlagsKHR
$cunsafeShiftR :: VkSemaphoreImportFlagsKHR -> Int -> VkSemaphoreImportFlagsKHR
shiftR :: VkSemaphoreImportFlagsKHR -> Int -> VkSemaphoreImportFlagsKHR
$cshiftR :: VkSemaphoreImportFlagsKHR -> Int -> VkSemaphoreImportFlagsKHR
unsafeShiftL :: VkSemaphoreImportFlagsKHR -> Int -> VkSemaphoreImportFlagsKHR
$cunsafeShiftL :: VkSemaphoreImportFlagsKHR -> Int -> VkSemaphoreImportFlagsKHR
shiftL :: VkSemaphoreImportFlagsKHR -> Int -> VkSemaphoreImportFlagsKHR
$cshiftL :: VkSemaphoreImportFlagsKHR -> Int -> VkSemaphoreImportFlagsKHR
isSigned :: VkSemaphoreImportFlagsKHR -> Bool
$cisSigned :: VkSemaphoreImportFlagsKHR -> Bool
bitSize :: VkSemaphoreImportFlagsKHR -> Int
$cbitSize :: VkSemaphoreImportFlagsKHR -> Int
bitSizeMaybe :: VkSemaphoreImportFlagsKHR -> Maybe Int
$cbitSizeMaybe :: VkSemaphoreImportFlagsKHR -> Maybe Int
testBit :: VkSemaphoreImportFlagsKHR -> Int -> Bool
$ctestBit :: VkSemaphoreImportFlagsKHR -> Int -> Bool
complementBit :: VkSemaphoreImportFlagsKHR -> Int -> VkSemaphoreImportFlagsKHR
$ccomplementBit :: VkSemaphoreImportFlagsKHR -> Int -> VkSemaphoreImportFlagsKHR
clearBit :: VkSemaphoreImportFlagsKHR -> Int -> VkSemaphoreImportFlagsKHR
$cclearBit :: VkSemaphoreImportFlagsKHR -> Int -> VkSemaphoreImportFlagsKHR
setBit :: VkSemaphoreImportFlagsKHR -> Int -> VkSemaphoreImportFlagsKHR
$csetBit :: VkSemaphoreImportFlagsKHR -> Int -> VkSemaphoreImportFlagsKHR
bit :: Int -> VkSemaphoreImportFlagsKHR
$cbit :: Int -> VkSemaphoreImportFlagsKHR
zeroBits :: VkSemaphoreImportFlagsKHR
$czeroBits :: VkSemaphoreImportFlagsKHR
rotate :: VkSemaphoreImportFlagsKHR -> Int -> VkSemaphoreImportFlagsKHR
$crotate :: VkSemaphoreImportFlagsKHR -> Int -> VkSemaphoreImportFlagsKHR
shift :: VkSemaphoreImportFlagsKHR -> Int -> VkSemaphoreImportFlagsKHR
$cshift :: VkSemaphoreImportFlagsKHR -> Int -> VkSemaphoreImportFlagsKHR
complement :: VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR
$ccomplement :: VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR
xor :: VkSemaphoreImportFlagsKHR
-> VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR
$cxor :: VkSemaphoreImportFlagsKHR
-> VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR
.|. :: VkSemaphoreImportFlagsKHR
-> VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR
$c.|. :: VkSemaphoreImportFlagsKHR
-> VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR
.&. :: VkSemaphoreImportFlagsKHR
-> VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR
$c.&. :: VkSemaphoreImportFlagsKHR
-> VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR
Bits, Bits VkSemaphoreImportFlagsKHR
Bits VkSemaphoreImportFlagsKHR
-> (VkSemaphoreImportFlagsKHR -> Int)
-> (VkSemaphoreImportFlagsKHR -> Int)
-> (VkSemaphoreImportFlagsKHR -> Int)
-> FiniteBits VkSemaphoreImportFlagsKHR
VkSemaphoreImportFlagsKHR -> Int
forall b.
Bits b -> (b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
countTrailingZeros :: VkSemaphoreImportFlagsKHR -> Int
$ccountTrailingZeros :: VkSemaphoreImportFlagsKHR -> Int
countLeadingZeros :: VkSemaphoreImportFlagsKHR -> Int
$ccountLeadingZeros :: VkSemaphoreImportFlagsKHR -> Int
finiteBitSize :: VkSemaphoreImportFlagsKHR -> Int
$cfiniteBitSize :: VkSemaphoreImportFlagsKHR -> Int
FiniteBits, Ptr VkSemaphoreImportFlagsKHR -> IO VkSemaphoreImportFlagsKHR
Ptr VkSemaphoreImportFlagsKHR
-> Int -> IO VkSemaphoreImportFlagsKHR
Ptr VkSemaphoreImportFlagsKHR
-> Int -> VkSemaphoreImportFlagsKHR -> IO ()
Ptr VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR -> IO ()
VkSemaphoreImportFlagsKHR -> Int
(VkSemaphoreImportFlagsKHR -> Int)
-> (VkSemaphoreImportFlagsKHR -> Int)
-> (Ptr VkSemaphoreImportFlagsKHR
    -> Int -> IO VkSemaphoreImportFlagsKHR)
-> (Ptr VkSemaphoreImportFlagsKHR
    -> Int -> VkSemaphoreImportFlagsKHR -> IO ())
-> (forall b. Ptr b -> Int -> IO VkSemaphoreImportFlagsKHR)
-> (forall b. Ptr b -> Int -> VkSemaphoreImportFlagsKHR -> IO ())
-> (Ptr VkSemaphoreImportFlagsKHR -> IO VkSemaphoreImportFlagsKHR)
-> (Ptr VkSemaphoreImportFlagsKHR
    -> VkSemaphoreImportFlagsKHR -> IO ())
-> Storable VkSemaphoreImportFlagsKHR
forall b. Ptr b -> Int -> IO VkSemaphoreImportFlagsKHR
forall b. Ptr b -> Int -> VkSemaphoreImportFlagsKHR -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR -> IO ()
$cpoke :: Ptr VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR -> IO ()
peek :: Ptr VkSemaphoreImportFlagsKHR -> IO VkSemaphoreImportFlagsKHR
$cpeek :: Ptr VkSemaphoreImportFlagsKHR -> IO VkSemaphoreImportFlagsKHR
pokeByteOff :: forall b. Ptr b -> Int -> VkSemaphoreImportFlagsKHR -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> VkSemaphoreImportFlagsKHR -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO VkSemaphoreImportFlagsKHR
$cpeekByteOff :: forall b. Ptr b -> Int -> IO VkSemaphoreImportFlagsKHR
pokeElemOff :: Ptr VkSemaphoreImportFlagsKHR
-> Int -> VkSemaphoreImportFlagsKHR -> IO ()
$cpokeElemOff :: Ptr VkSemaphoreImportFlagsKHR
-> Int -> VkSemaphoreImportFlagsKHR -> IO ()
peekElemOff :: Ptr VkSemaphoreImportFlagsKHR
-> Int -> IO VkSemaphoreImportFlagsKHR
$cpeekElemOff :: Ptr VkSemaphoreImportFlagsKHR
-> Int -> IO VkSemaphoreImportFlagsKHR
alignment :: VkSemaphoreImportFlagsKHR -> Int
$calignment :: VkSemaphoreImportFlagsKHR -> Int
sizeOf :: VkSemaphoreImportFlagsKHR -> Int
$csizeOf :: VkSemaphoreImportFlagsKHR -> Int
Storable)

instance Show VkSemaphoreImportFlagsKHR where
    {-# INLINE showsPrec #-}
    showsPrec :: Int -> VkSemaphoreImportFlagsKHR -> ShowS
showsPrec = (Int -> VkFlags -> ShowS)
-> Int -> VkSemaphoreImportFlagsKHR -> ShowS
coerce (Int -> VkFlags -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec :: Int -> VkFlags -> ShowS)

instance Read VkSemaphoreImportFlagsKHR where
    {-# INLINE readsPrec #-}
    readsPrec :: Int -> ReadS VkSemaphoreImportFlagsKHR
readsPrec = (Int -> ReadS VkFlags) -> Int -> ReadS VkSemaphoreImportFlagsKHR
coerce (Int -> ReadS VkFlags
forall a. Read a => Int -> ReadS a
readsPrec :: Int -> ReadS VkFlags)

newtype VkSemaphoreWaitFlagsKHR = VkSemaphoreWaitFlagsKHR VkFlags
                                  deriving (VkSemaphoreWaitFlagsKHR -> VkSemaphoreWaitFlagsKHR -> Bool
(VkSemaphoreWaitFlagsKHR -> VkSemaphoreWaitFlagsKHR -> Bool)
-> (VkSemaphoreWaitFlagsKHR -> VkSemaphoreWaitFlagsKHR -> Bool)
-> Eq VkSemaphoreWaitFlagsKHR
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VkSemaphoreWaitFlagsKHR -> VkSemaphoreWaitFlagsKHR -> Bool
$c/= :: VkSemaphoreWaitFlagsKHR -> VkSemaphoreWaitFlagsKHR -> Bool
== :: VkSemaphoreWaitFlagsKHR -> VkSemaphoreWaitFlagsKHR -> Bool
$c== :: VkSemaphoreWaitFlagsKHR -> VkSemaphoreWaitFlagsKHR -> Bool
Eq, Eq VkSemaphoreWaitFlagsKHR
Eq VkSemaphoreWaitFlagsKHR
-> (VkSemaphoreWaitFlagsKHR -> VkSemaphoreWaitFlagsKHR -> Ordering)
-> (VkSemaphoreWaitFlagsKHR -> VkSemaphoreWaitFlagsKHR -> Bool)
-> (VkSemaphoreWaitFlagsKHR -> VkSemaphoreWaitFlagsKHR -> Bool)
-> (VkSemaphoreWaitFlagsKHR -> VkSemaphoreWaitFlagsKHR -> Bool)
-> (VkSemaphoreWaitFlagsKHR -> VkSemaphoreWaitFlagsKHR -> Bool)
-> (VkSemaphoreWaitFlagsKHR
    -> VkSemaphoreWaitFlagsKHR -> VkSemaphoreWaitFlagsKHR)
-> (VkSemaphoreWaitFlagsKHR
    -> VkSemaphoreWaitFlagsKHR -> VkSemaphoreWaitFlagsKHR)
-> Ord VkSemaphoreWaitFlagsKHR
VkSemaphoreWaitFlagsKHR -> VkSemaphoreWaitFlagsKHR -> Bool
VkSemaphoreWaitFlagsKHR -> VkSemaphoreWaitFlagsKHR -> Ordering
VkSemaphoreWaitFlagsKHR
-> VkSemaphoreWaitFlagsKHR -> VkSemaphoreWaitFlagsKHR
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: VkSemaphoreWaitFlagsKHR
-> VkSemaphoreWaitFlagsKHR -> VkSemaphoreWaitFlagsKHR
$cmin :: VkSemaphoreWaitFlagsKHR
-> VkSemaphoreWaitFlagsKHR -> VkSemaphoreWaitFlagsKHR
max :: VkSemaphoreWaitFlagsKHR
-> VkSemaphoreWaitFlagsKHR -> VkSemaphoreWaitFlagsKHR
$cmax :: VkSemaphoreWaitFlagsKHR
-> VkSemaphoreWaitFlagsKHR -> VkSemaphoreWaitFlagsKHR
>= :: VkSemaphoreWaitFlagsKHR -> VkSemaphoreWaitFlagsKHR -> Bool
$c>= :: VkSemaphoreWaitFlagsKHR -> VkSemaphoreWaitFlagsKHR -> Bool
> :: VkSemaphoreWaitFlagsKHR -> VkSemaphoreWaitFlagsKHR -> Bool
$c> :: VkSemaphoreWaitFlagsKHR -> VkSemaphoreWaitFlagsKHR -> Bool
<= :: VkSemaphoreWaitFlagsKHR -> VkSemaphoreWaitFlagsKHR -> Bool
$c<= :: VkSemaphoreWaitFlagsKHR -> VkSemaphoreWaitFlagsKHR -> Bool
< :: VkSemaphoreWaitFlagsKHR -> VkSemaphoreWaitFlagsKHR -> Bool
$c< :: VkSemaphoreWaitFlagsKHR -> VkSemaphoreWaitFlagsKHR -> Bool
compare :: VkSemaphoreWaitFlagsKHR -> VkSemaphoreWaitFlagsKHR -> Ordering
$ccompare :: VkSemaphoreWaitFlagsKHR -> VkSemaphoreWaitFlagsKHR -> Ordering
Ord, Int -> VkSemaphoreWaitFlagsKHR
VkSemaphoreWaitFlagsKHR -> Int
VkSemaphoreWaitFlagsKHR -> [VkSemaphoreWaitFlagsKHR]
VkSemaphoreWaitFlagsKHR -> VkSemaphoreWaitFlagsKHR
VkSemaphoreWaitFlagsKHR
-> VkSemaphoreWaitFlagsKHR -> [VkSemaphoreWaitFlagsKHR]
VkSemaphoreWaitFlagsKHR
-> VkSemaphoreWaitFlagsKHR
-> VkSemaphoreWaitFlagsKHR
-> [VkSemaphoreWaitFlagsKHR]
(VkSemaphoreWaitFlagsKHR -> VkSemaphoreWaitFlagsKHR)
-> (VkSemaphoreWaitFlagsKHR -> VkSemaphoreWaitFlagsKHR)
-> (Int -> VkSemaphoreWaitFlagsKHR)
-> (VkSemaphoreWaitFlagsKHR -> Int)
-> (VkSemaphoreWaitFlagsKHR -> [VkSemaphoreWaitFlagsKHR])
-> (VkSemaphoreWaitFlagsKHR
    -> VkSemaphoreWaitFlagsKHR -> [VkSemaphoreWaitFlagsKHR])
-> (VkSemaphoreWaitFlagsKHR
    -> VkSemaphoreWaitFlagsKHR -> [VkSemaphoreWaitFlagsKHR])
-> (VkSemaphoreWaitFlagsKHR
    -> VkSemaphoreWaitFlagsKHR
    -> VkSemaphoreWaitFlagsKHR
    -> [VkSemaphoreWaitFlagsKHR])
-> Enum VkSemaphoreWaitFlagsKHR
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: VkSemaphoreWaitFlagsKHR
-> VkSemaphoreWaitFlagsKHR
-> VkSemaphoreWaitFlagsKHR
-> [VkSemaphoreWaitFlagsKHR]
$cenumFromThenTo :: VkSemaphoreWaitFlagsKHR
-> VkSemaphoreWaitFlagsKHR
-> VkSemaphoreWaitFlagsKHR
-> [VkSemaphoreWaitFlagsKHR]
enumFromTo :: VkSemaphoreWaitFlagsKHR
-> VkSemaphoreWaitFlagsKHR -> [VkSemaphoreWaitFlagsKHR]
$cenumFromTo :: VkSemaphoreWaitFlagsKHR
-> VkSemaphoreWaitFlagsKHR -> [VkSemaphoreWaitFlagsKHR]
enumFromThen :: VkSemaphoreWaitFlagsKHR
-> VkSemaphoreWaitFlagsKHR -> [VkSemaphoreWaitFlagsKHR]
$cenumFromThen :: VkSemaphoreWaitFlagsKHR
-> VkSemaphoreWaitFlagsKHR -> [VkSemaphoreWaitFlagsKHR]
enumFrom :: VkSemaphoreWaitFlagsKHR -> [VkSemaphoreWaitFlagsKHR]
$cenumFrom :: VkSemaphoreWaitFlagsKHR -> [VkSemaphoreWaitFlagsKHR]
fromEnum :: VkSemaphoreWaitFlagsKHR -> Int
$cfromEnum :: VkSemaphoreWaitFlagsKHR -> Int
toEnum :: Int -> VkSemaphoreWaitFlagsKHR
$ctoEnum :: Int -> VkSemaphoreWaitFlagsKHR
pred :: VkSemaphoreWaitFlagsKHR -> VkSemaphoreWaitFlagsKHR
$cpred :: VkSemaphoreWaitFlagsKHR -> VkSemaphoreWaitFlagsKHR
succ :: VkSemaphoreWaitFlagsKHR -> VkSemaphoreWaitFlagsKHR
$csucc :: VkSemaphoreWaitFlagsKHR -> VkSemaphoreWaitFlagsKHR
Enum, Eq VkSemaphoreWaitFlagsKHR
VkSemaphoreWaitFlagsKHR
Eq VkSemaphoreWaitFlagsKHR
-> (VkSemaphoreWaitFlagsKHR
    -> VkSemaphoreWaitFlagsKHR -> VkSemaphoreWaitFlagsKHR)
-> (VkSemaphoreWaitFlagsKHR
    -> VkSemaphoreWaitFlagsKHR -> VkSemaphoreWaitFlagsKHR)
-> (VkSemaphoreWaitFlagsKHR
    -> VkSemaphoreWaitFlagsKHR -> VkSemaphoreWaitFlagsKHR)
-> (VkSemaphoreWaitFlagsKHR -> VkSemaphoreWaitFlagsKHR)
-> (VkSemaphoreWaitFlagsKHR -> Int -> VkSemaphoreWaitFlagsKHR)
-> (VkSemaphoreWaitFlagsKHR -> Int -> VkSemaphoreWaitFlagsKHR)
-> VkSemaphoreWaitFlagsKHR
-> (Int -> VkSemaphoreWaitFlagsKHR)
-> (VkSemaphoreWaitFlagsKHR -> Int -> VkSemaphoreWaitFlagsKHR)
-> (VkSemaphoreWaitFlagsKHR -> Int -> VkSemaphoreWaitFlagsKHR)
-> (VkSemaphoreWaitFlagsKHR -> Int -> VkSemaphoreWaitFlagsKHR)
-> (VkSemaphoreWaitFlagsKHR -> Int -> Bool)
-> (VkSemaphoreWaitFlagsKHR -> Maybe Int)
-> (VkSemaphoreWaitFlagsKHR -> Int)
-> (VkSemaphoreWaitFlagsKHR -> Bool)
-> (VkSemaphoreWaitFlagsKHR -> Int -> VkSemaphoreWaitFlagsKHR)
-> (VkSemaphoreWaitFlagsKHR -> Int -> VkSemaphoreWaitFlagsKHR)
-> (VkSemaphoreWaitFlagsKHR -> Int -> VkSemaphoreWaitFlagsKHR)
-> (VkSemaphoreWaitFlagsKHR -> Int -> VkSemaphoreWaitFlagsKHR)
-> (VkSemaphoreWaitFlagsKHR -> Int -> VkSemaphoreWaitFlagsKHR)
-> (VkSemaphoreWaitFlagsKHR -> Int -> VkSemaphoreWaitFlagsKHR)
-> (VkSemaphoreWaitFlagsKHR -> Int)
-> Bits VkSemaphoreWaitFlagsKHR
Int -> VkSemaphoreWaitFlagsKHR
VkSemaphoreWaitFlagsKHR -> Bool
VkSemaphoreWaitFlagsKHR -> Int
VkSemaphoreWaitFlagsKHR -> Maybe Int
VkSemaphoreWaitFlagsKHR -> VkSemaphoreWaitFlagsKHR
VkSemaphoreWaitFlagsKHR -> Int -> Bool
VkSemaphoreWaitFlagsKHR -> Int -> VkSemaphoreWaitFlagsKHR
VkSemaphoreWaitFlagsKHR
-> VkSemaphoreWaitFlagsKHR -> VkSemaphoreWaitFlagsKHR
forall a.
Eq a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
popCount :: VkSemaphoreWaitFlagsKHR -> Int
$cpopCount :: VkSemaphoreWaitFlagsKHR -> Int
rotateR :: VkSemaphoreWaitFlagsKHR -> Int -> VkSemaphoreWaitFlagsKHR
$crotateR :: VkSemaphoreWaitFlagsKHR -> Int -> VkSemaphoreWaitFlagsKHR
rotateL :: VkSemaphoreWaitFlagsKHR -> Int -> VkSemaphoreWaitFlagsKHR
$crotateL :: VkSemaphoreWaitFlagsKHR -> Int -> VkSemaphoreWaitFlagsKHR
unsafeShiftR :: VkSemaphoreWaitFlagsKHR -> Int -> VkSemaphoreWaitFlagsKHR
$cunsafeShiftR :: VkSemaphoreWaitFlagsKHR -> Int -> VkSemaphoreWaitFlagsKHR
shiftR :: VkSemaphoreWaitFlagsKHR -> Int -> VkSemaphoreWaitFlagsKHR
$cshiftR :: VkSemaphoreWaitFlagsKHR -> Int -> VkSemaphoreWaitFlagsKHR
unsafeShiftL :: VkSemaphoreWaitFlagsKHR -> Int -> VkSemaphoreWaitFlagsKHR
$cunsafeShiftL :: VkSemaphoreWaitFlagsKHR -> Int -> VkSemaphoreWaitFlagsKHR
shiftL :: VkSemaphoreWaitFlagsKHR -> Int -> VkSemaphoreWaitFlagsKHR
$cshiftL :: VkSemaphoreWaitFlagsKHR -> Int -> VkSemaphoreWaitFlagsKHR
isSigned :: VkSemaphoreWaitFlagsKHR -> Bool
$cisSigned :: VkSemaphoreWaitFlagsKHR -> Bool
bitSize :: VkSemaphoreWaitFlagsKHR -> Int
$cbitSize :: VkSemaphoreWaitFlagsKHR -> Int
bitSizeMaybe :: VkSemaphoreWaitFlagsKHR -> Maybe Int
$cbitSizeMaybe :: VkSemaphoreWaitFlagsKHR -> Maybe Int
testBit :: VkSemaphoreWaitFlagsKHR -> Int -> Bool
$ctestBit :: VkSemaphoreWaitFlagsKHR -> Int -> Bool
complementBit :: VkSemaphoreWaitFlagsKHR -> Int -> VkSemaphoreWaitFlagsKHR
$ccomplementBit :: VkSemaphoreWaitFlagsKHR -> Int -> VkSemaphoreWaitFlagsKHR
clearBit :: VkSemaphoreWaitFlagsKHR -> Int -> VkSemaphoreWaitFlagsKHR
$cclearBit :: VkSemaphoreWaitFlagsKHR -> Int -> VkSemaphoreWaitFlagsKHR
setBit :: VkSemaphoreWaitFlagsKHR -> Int -> VkSemaphoreWaitFlagsKHR
$csetBit :: VkSemaphoreWaitFlagsKHR -> Int -> VkSemaphoreWaitFlagsKHR
bit :: Int -> VkSemaphoreWaitFlagsKHR
$cbit :: Int -> VkSemaphoreWaitFlagsKHR
zeroBits :: VkSemaphoreWaitFlagsKHR
$czeroBits :: VkSemaphoreWaitFlagsKHR
rotate :: VkSemaphoreWaitFlagsKHR -> Int -> VkSemaphoreWaitFlagsKHR
$crotate :: VkSemaphoreWaitFlagsKHR -> Int -> VkSemaphoreWaitFlagsKHR
shift :: VkSemaphoreWaitFlagsKHR -> Int -> VkSemaphoreWaitFlagsKHR
$cshift :: VkSemaphoreWaitFlagsKHR -> Int -> VkSemaphoreWaitFlagsKHR
complement :: VkSemaphoreWaitFlagsKHR -> VkSemaphoreWaitFlagsKHR
$ccomplement :: VkSemaphoreWaitFlagsKHR -> VkSemaphoreWaitFlagsKHR
xor :: VkSemaphoreWaitFlagsKHR
-> VkSemaphoreWaitFlagsKHR -> VkSemaphoreWaitFlagsKHR
$cxor :: VkSemaphoreWaitFlagsKHR
-> VkSemaphoreWaitFlagsKHR -> VkSemaphoreWaitFlagsKHR
.|. :: VkSemaphoreWaitFlagsKHR
-> VkSemaphoreWaitFlagsKHR -> VkSemaphoreWaitFlagsKHR
$c.|. :: VkSemaphoreWaitFlagsKHR
-> VkSemaphoreWaitFlagsKHR -> VkSemaphoreWaitFlagsKHR
.&. :: VkSemaphoreWaitFlagsKHR
-> VkSemaphoreWaitFlagsKHR -> VkSemaphoreWaitFlagsKHR
$c.&. :: VkSemaphoreWaitFlagsKHR
-> VkSemaphoreWaitFlagsKHR -> VkSemaphoreWaitFlagsKHR
Bits, Bits VkSemaphoreWaitFlagsKHR
Bits VkSemaphoreWaitFlagsKHR
-> (VkSemaphoreWaitFlagsKHR -> Int)
-> (VkSemaphoreWaitFlagsKHR -> Int)
-> (VkSemaphoreWaitFlagsKHR -> Int)
-> FiniteBits VkSemaphoreWaitFlagsKHR
VkSemaphoreWaitFlagsKHR -> Int
forall b.
Bits b -> (b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
countTrailingZeros :: VkSemaphoreWaitFlagsKHR -> Int
$ccountTrailingZeros :: VkSemaphoreWaitFlagsKHR -> Int
countLeadingZeros :: VkSemaphoreWaitFlagsKHR -> Int
$ccountLeadingZeros :: VkSemaphoreWaitFlagsKHR -> Int
finiteBitSize :: VkSemaphoreWaitFlagsKHR -> Int
$cfiniteBitSize :: VkSemaphoreWaitFlagsKHR -> Int
FiniteBits, Ptr VkSemaphoreWaitFlagsKHR -> IO VkSemaphoreWaitFlagsKHR
Ptr VkSemaphoreWaitFlagsKHR -> Int -> IO VkSemaphoreWaitFlagsKHR
Ptr VkSemaphoreWaitFlagsKHR
-> Int -> VkSemaphoreWaitFlagsKHR -> IO ()
Ptr VkSemaphoreWaitFlagsKHR -> VkSemaphoreWaitFlagsKHR -> IO ()
VkSemaphoreWaitFlagsKHR -> Int
(VkSemaphoreWaitFlagsKHR -> Int)
-> (VkSemaphoreWaitFlagsKHR -> Int)
-> (Ptr VkSemaphoreWaitFlagsKHR
    -> Int -> IO VkSemaphoreWaitFlagsKHR)
-> (Ptr VkSemaphoreWaitFlagsKHR
    -> Int -> VkSemaphoreWaitFlagsKHR -> IO ())
-> (forall b. Ptr b -> Int -> IO VkSemaphoreWaitFlagsKHR)
-> (forall b. Ptr b -> Int -> VkSemaphoreWaitFlagsKHR -> IO ())
-> (Ptr VkSemaphoreWaitFlagsKHR -> IO VkSemaphoreWaitFlagsKHR)
-> (Ptr VkSemaphoreWaitFlagsKHR
    -> VkSemaphoreWaitFlagsKHR -> IO ())
-> Storable VkSemaphoreWaitFlagsKHR
forall b. Ptr b -> Int -> IO VkSemaphoreWaitFlagsKHR
forall b. Ptr b -> Int -> VkSemaphoreWaitFlagsKHR -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr VkSemaphoreWaitFlagsKHR -> VkSemaphoreWaitFlagsKHR -> IO ()
$cpoke :: Ptr VkSemaphoreWaitFlagsKHR -> VkSemaphoreWaitFlagsKHR -> IO ()
peek :: Ptr VkSemaphoreWaitFlagsKHR -> IO VkSemaphoreWaitFlagsKHR
$cpeek :: Ptr VkSemaphoreWaitFlagsKHR -> IO VkSemaphoreWaitFlagsKHR
pokeByteOff :: forall b. Ptr b -> Int -> VkSemaphoreWaitFlagsKHR -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> VkSemaphoreWaitFlagsKHR -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO VkSemaphoreWaitFlagsKHR
$cpeekByteOff :: forall b. Ptr b -> Int -> IO VkSemaphoreWaitFlagsKHR
pokeElemOff :: Ptr VkSemaphoreWaitFlagsKHR
-> Int -> VkSemaphoreWaitFlagsKHR -> IO ()
$cpokeElemOff :: Ptr VkSemaphoreWaitFlagsKHR
-> Int -> VkSemaphoreWaitFlagsKHR -> IO ()
peekElemOff :: Ptr VkSemaphoreWaitFlagsKHR -> Int -> IO VkSemaphoreWaitFlagsKHR
$cpeekElemOff :: Ptr VkSemaphoreWaitFlagsKHR -> Int -> IO VkSemaphoreWaitFlagsKHR
alignment :: VkSemaphoreWaitFlagsKHR -> Int
$calignment :: VkSemaphoreWaitFlagsKHR -> Int
sizeOf :: VkSemaphoreWaitFlagsKHR -> Int
$csizeOf :: VkSemaphoreWaitFlagsKHR -> Int
Storable)

instance Show VkSemaphoreWaitFlagsKHR where
    {-# INLINE showsPrec #-}
    showsPrec :: Int -> VkSemaphoreWaitFlagsKHR -> ShowS
showsPrec = (Int -> VkFlags -> ShowS)
-> Int -> VkSemaphoreWaitFlagsKHR -> ShowS
coerce (Int -> VkFlags -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec :: Int -> VkFlags -> ShowS)

instance Read VkSemaphoreWaitFlagsKHR where
    {-# INLINE readsPrec #-}
    readsPrec :: Int -> ReadS VkSemaphoreWaitFlagsKHR
readsPrec = (Int -> ReadS VkFlags) -> Int -> ReadS VkSemaphoreWaitFlagsKHR
coerce (Int -> ReadS VkFlags
forall a. Read a => Int -> ReadS a
readsPrec :: Int -> ReadS VkFlags)

newtype VkStreamDescriptorSurfaceCreateFlagsGGP = VkStreamDescriptorSurfaceCreateFlagsGGP VkFlags
                                                  deriving (VkStreamDescriptorSurfaceCreateFlagsGGP
-> VkStreamDescriptorSurfaceCreateFlagsGGP -> Bool
(VkStreamDescriptorSurfaceCreateFlagsGGP
 -> VkStreamDescriptorSurfaceCreateFlagsGGP -> Bool)
-> (VkStreamDescriptorSurfaceCreateFlagsGGP
    -> VkStreamDescriptorSurfaceCreateFlagsGGP -> Bool)
-> Eq VkStreamDescriptorSurfaceCreateFlagsGGP
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VkStreamDescriptorSurfaceCreateFlagsGGP
-> VkStreamDescriptorSurfaceCreateFlagsGGP -> Bool
$c/= :: VkStreamDescriptorSurfaceCreateFlagsGGP
-> VkStreamDescriptorSurfaceCreateFlagsGGP -> Bool
== :: VkStreamDescriptorSurfaceCreateFlagsGGP
-> VkStreamDescriptorSurfaceCreateFlagsGGP -> Bool
$c== :: VkStreamDescriptorSurfaceCreateFlagsGGP
-> VkStreamDescriptorSurfaceCreateFlagsGGP -> Bool
Eq, Eq VkStreamDescriptorSurfaceCreateFlagsGGP
Eq VkStreamDescriptorSurfaceCreateFlagsGGP
-> (VkStreamDescriptorSurfaceCreateFlagsGGP
    -> VkStreamDescriptorSurfaceCreateFlagsGGP -> Ordering)
-> (VkStreamDescriptorSurfaceCreateFlagsGGP
    -> VkStreamDescriptorSurfaceCreateFlagsGGP -> Bool)
-> (VkStreamDescriptorSurfaceCreateFlagsGGP
    -> VkStreamDescriptorSurfaceCreateFlagsGGP -> Bool)
-> (VkStreamDescriptorSurfaceCreateFlagsGGP
    -> VkStreamDescriptorSurfaceCreateFlagsGGP -> Bool)
-> (VkStreamDescriptorSurfaceCreateFlagsGGP
    -> VkStreamDescriptorSurfaceCreateFlagsGGP -> Bool)
-> (VkStreamDescriptorSurfaceCreateFlagsGGP
    -> VkStreamDescriptorSurfaceCreateFlagsGGP
    -> VkStreamDescriptorSurfaceCreateFlagsGGP)
-> (VkStreamDescriptorSurfaceCreateFlagsGGP
    -> VkStreamDescriptorSurfaceCreateFlagsGGP
    -> VkStreamDescriptorSurfaceCreateFlagsGGP)
-> Ord VkStreamDescriptorSurfaceCreateFlagsGGP
VkStreamDescriptorSurfaceCreateFlagsGGP
-> VkStreamDescriptorSurfaceCreateFlagsGGP -> Bool
VkStreamDescriptorSurfaceCreateFlagsGGP
-> VkStreamDescriptorSurfaceCreateFlagsGGP -> Ordering
VkStreamDescriptorSurfaceCreateFlagsGGP
-> VkStreamDescriptorSurfaceCreateFlagsGGP
-> VkStreamDescriptorSurfaceCreateFlagsGGP
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: VkStreamDescriptorSurfaceCreateFlagsGGP
-> VkStreamDescriptorSurfaceCreateFlagsGGP
-> VkStreamDescriptorSurfaceCreateFlagsGGP
$cmin :: VkStreamDescriptorSurfaceCreateFlagsGGP
-> VkStreamDescriptorSurfaceCreateFlagsGGP
-> VkStreamDescriptorSurfaceCreateFlagsGGP
max :: VkStreamDescriptorSurfaceCreateFlagsGGP
-> VkStreamDescriptorSurfaceCreateFlagsGGP
-> VkStreamDescriptorSurfaceCreateFlagsGGP
$cmax :: VkStreamDescriptorSurfaceCreateFlagsGGP
-> VkStreamDescriptorSurfaceCreateFlagsGGP
-> VkStreamDescriptorSurfaceCreateFlagsGGP
>= :: VkStreamDescriptorSurfaceCreateFlagsGGP
-> VkStreamDescriptorSurfaceCreateFlagsGGP -> Bool
$c>= :: VkStreamDescriptorSurfaceCreateFlagsGGP
-> VkStreamDescriptorSurfaceCreateFlagsGGP -> Bool
> :: VkStreamDescriptorSurfaceCreateFlagsGGP
-> VkStreamDescriptorSurfaceCreateFlagsGGP -> Bool
$c> :: VkStreamDescriptorSurfaceCreateFlagsGGP
-> VkStreamDescriptorSurfaceCreateFlagsGGP -> Bool
<= :: VkStreamDescriptorSurfaceCreateFlagsGGP
-> VkStreamDescriptorSurfaceCreateFlagsGGP -> Bool
$c<= :: VkStreamDescriptorSurfaceCreateFlagsGGP
-> VkStreamDescriptorSurfaceCreateFlagsGGP -> Bool
< :: VkStreamDescriptorSurfaceCreateFlagsGGP
-> VkStreamDescriptorSurfaceCreateFlagsGGP -> Bool
$c< :: VkStreamDescriptorSurfaceCreateFlagsGGP
-> VkStreamDescriptorSurfaceCreateFlagsGGP -> Bool
compare :: VkStreamDescriptorSurfaceCreateFlagsGGP
-> VkStreamDescriptorSurfaceCreateFlagsGGP -> Ordering
$ccompare :: VkStreamDescriptorSurfaceCreateFlagsGGP
-> VkStreamDescriptorSurfaceCreateFlagsGGP -> Ordering
Ord, Int -> VkStreamDescriptorSurfaceCreateFlagsGGP
VkStreamDescriptorSurfaceCreateFlagsGGP -> Int
VkStreamDescriptorSurfaceCreateFlagsGGP
-> [VkStreamDescriptorSurfaceCreateFlagsGGP]
VkStreamDescriptorSurfaceCreateFlagsGGP
-> VkStreamDescriptorSurfaceCreateFlagsGGP
VkStreamDescriptorSurfaceCreateFlagsGGP
-> VkStreamDescriptorSurfaceCreateFlagsGGP
-> [VkStreamDescriptorSurfaceCreateFlagsGGP]
VkStreamDescriptorSurfaceCreateFlagsGGP
-> VkStreamDescriptorSurfaceCreateFlagsGGP
-> VkStreamDescriptorSurfaceCreateFlagsGGP
-> [VkStreamDescriptorSurfaceCreateFlagsGGP]
(VkStreamDescriptorSurfaceCreateFlagsGGP
 -> VkStreamDescriptorSurfaceCreateFlagsGGP)
-> (VkStreamDescriptorSurfaceCreateFlagsGGP
    -> VkStreamDescriptorSurfaceCreateFlagsGGP)
-> (Int -> VkStreamDescriptorSurfaceCreateFlagsGGP)
-> (VkStreamDescriptorSurfaceCreateFlagsGGP -> Int)
-> (VkStreamDescriptorSurfaceCreateFlagsGGP
    -> [VkStreamDescriptorSurfaceCreateFlagsGGP])
-> (VkStreamDescriptorSurfaceCreateFlagsGGP
    -> VkStreamDescriptorSurfaceCreateFlagsGGP
    -> [VkStreamDescriptorSurfaceCreateFlagsGGP])
-> (VkStreamDescriptorSurfaceCreateFlagsGGP
    -> VkStreamDescriptorSurfaceCreateFlagsGGP
    -> [VkStreamDescriptorSurfaceCreateFlagsGGP])
-> (VkStreamDescriptorSurfaceCreateFlagsGGP
    -> VkStreamDescriptorSurfaceCreateFlagsGGP
    -> VkStreamDescriptorSurfaceCreateFlagsGGP
    -> [VkStreamDescriptorSurfaceCreateFlagsGGP])
-> Enum VkStreamDescriptorSurfaceCreateFlagsGGP
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: VkStreamDescriptorSurfaceCreateFlagsGGP
-> VkStreamDescriptorSurfaceCreateFlagsGGP
-> VkStreamDescriptorSurfaceCreateFlagsGGP
-> [VkStreamDescriptorSurfaceCreateFlagsGGP]
$cenumFromThenTo :: VkStreamDescriptorSurfaceCreateFlagsGGP
-> VkStreamDescriptorSurfaceCreateFlagsGGP
-> VkStreamDescriptorSurfaceCreateFlagsGGP
-> [VkStreamDescriptorSurfaceCreateFlagsGGP]
enumFromTo :: VkStreamDescriptorSurfaceCreateFlagsGGP
-> VkStreamDescriptorSurfaceCreateFlagsGGP
-> [VkStreamDescriptorSurfaceCreateFlagsGGP]
$cenumFromTo :: VkStreamDescriptorSurfaceCreateFlagsGGP
-> VkStreamDescriptorSurfaceCreateFlagsGGP
-> [VkStreamDescriptorSurfaceCreateFlagsGGP]
enumFromThen :: VkStreamDescriptorSurfaceCreateFlagsGGP
-> VkStreamDescriptorSurfaceCreateFlagsGGP
-> [VkStreamDescriptorSurfaceCreateFlagsGGP]
$cenumFromThen :: VkStreamDescriptorSurfaceCreateFlagsGGP
-> VkStreamDescriptorSurfaceCreateFlagsGGP
-> [VkStreamDescriptorSurfaceCreateFlagsGGP]
enumFrom :: VkStreamDescriptorSurfaceCreateFlagsGGP
-> [VkStreamDescriptorSurfaceCreateFlagsGGP]
$cenumFrom :: VkStreamDescriptorSurfaceCreateFlagsGGP
-> [VkStreamDescriptorSurfaceCreateFlagsGGP]
fromEnum :: VkStreamDescriptorSurfaceCreateFlagsGGP -> Int
$cfromEnum :: VkStreamDescriptorSurfaceCreateFlagsGGP -> Int
toEnum :: Int -> VkStreamDescriptorSurfaceCreateFlagsGGP
$ctoEnum :: Int -> VkStreamDescriptorSurfaceCreateFlagsGGP
pred :: VkStreamDescriptorSurfaceCreateFlagsGGP
-> VkStreamDescriptorSurfaceCreateFlagsGGP
$cpred :: VkStreamDescriptorSurfaceCreateFlagsGGP
-> VkStreamDescriptorSurfaceCreateFlagsGGP
succ :: VkStreamDescriptorSurfaceCreateFlagsGGP
-> VkStreamDescriptorSurfaceCreateFlagsGGP
$csucc :: VkStreamDescriptorSurfaceCreateFlagsGGP
-> VkStreamDescriptorSurfaceCreateFlagsGGP
Enum, Eq VkStreamDescriptorSurfaceCreateFlagsGGP
VkStreamDescriptorSurfaceCreateFlagsGGP
Eq VkStreamDescriptorSurfaceCreateFlagsGGP
-> (VkStreamDescriptorSurfaceCreateFlagsGGP
    -> VkStreamDescriptorSurfaceCreateFlagsGGP
    -> VkStreamDescriptorSurfaceCreateFlagsGGP)
-> (VkStreamDescriptorSurfaceCreateFlagsGGP
    -> VkStreamDescriptorSurfaceCreateFlagsGGP
    -> VkStreamDescriptorSurfaceCreateFlagsGGP)
-> (VkStreamDescriptorSurfaceCreateFlagsGGP
    -> VkStreamDescriptorSurfaceCreateFlagsGGP
    -> VkStreamDescriptorSurfaceCreateFlagsGGP)
-> (VkStreamDescriptorSurfaceCreateFlagsGGP
    -> VkStreamDescriptorSurfaceCreateFlagsGGP)
-> (VkStreamDescriptorSurfaceCreateFlagsGGP
    -> Int -> VkStreamDescriptorSurfaceCreateFlagsGGP)
-> (VkStreamDescriptorSurfaceCreateFlagsGGP
    -> Int -> VkStreamDescriptorSurfaceCreateFlagsGGP)
-> VkStreamDescriptorSurfaceCreateFlagsGGP
-> (Int -> VkStreamDescriptorSurfaceCreateFlagsGGP)
-> (VkStreamDescriptorSurfaceCreateFlagsGGP
    -> Int -> VkStreamDescriptorSurfaceCreateFlagsGGP)
-> (VkStreamDescriptorSurfaceCreateFlagsGGP
    -> Int -> VkStreamDescriptorSurfaceCreateFlagsGGP)
-> (VkStreamDescriptorSurfaceCreateFlagsGGP
    -> Int -> VkStreamDescriptorSurfaceCreateFlagsGGP)
-> (VkStreamDescriptorSurfaceCreateFlagsGGP -> Int -> Bool)
-> (VkStreamDescriptorSurfaceCreateFlagsGGP -> Maybe Int)
-> (VkStreamDescriptorSurfaceCreateFlagsGGP -> Int)
-> (VkStreamDescriptorSurfaceCreateFlagsGGP -> Bool)
-> (VkStreamDescriptorSurfaceCreateFlagsGGP
    -> Int -> VkStreamDescriptorSurfaceCreateFlagsGGP)
-> (VkStreamDescriptorSurfaceCreateFlagsGGP
    -> Int -> VkStreamDescriptorSurfaceCreateFlagsGGP)
-> (VkStreamDescriptorSurfaceCreateFlagsGGP
    -> Int -> VkStreamDescriptorSurfaceCreateFlagsGGP)
-> (VkStreamDescriptorSurfaceCreateFlagsGGP
    -> Int -> VkStreamDescriptorSurfaceCreateFlagsGGP)
-> (VkStreamDescriptorSurfaceCreateFlagsGGP
    -> Int -> VkStreamDescriptorSurfaceCreateFlagsGGP)
-> (VkStreamDescriptorSurfaceCreateFlagsGGP
    -> Int -> VkStreamDescriptorSurfaceCreateFlagsGGP)
-> (VkStreamDescriptorSurfaceCreateFlagsGGP -> Int)
-> Bits VkStreamDescriptorSurfaceCreateFlagsGGP
Int -> VkStreamDescriptorSurfaceCreateFlagsGGP
VkStreamDescriptorSurfaceCreateFlagsGGP -> Bool
VkStreamDescriptorSurfaceCreateFlagsGGP -> Int
VkStreamDescriptorSurfaceCreateFlagsGGP -> Maybe Int
VkStreamDescriptorSurfaceCreateFlagsGGP
-> VkStreamDescriptorSurfaceCreateFlagsGGP
VkStreamDescriptorSurfaceCreateFlagsGGP -> Int -> Bool
VkStreamDescriptorSurfaceCreateFlagsGGP
-> Int -> VkStreamDescriptorSurfaceCreateFlagsGGP
VkStreamDescriptorSurfaceCreateFlagsGGP
-> VkStreamDescriptorSurfaceCreateFlagsGGP
-> VkStreamDescriptorSurfaceCreateFlagsGGP
forall a.
Eq a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
popCount :: VkStreamDescriptorSurfaceCreateFlagsGGP -> Int
$cpopCount :: VkStreamDescriptorSurfaceCreateFlagsGGP -> Int
rotateR :: VkStreamDescriptorSurfaceCreateFlagsGGP
-> Int -> VkStreamDescriptorSurfaceCreateFlagsGGP
$crotateR :: VkStreamDescriptorSurfaceCreateFlagsGGP
-> Int -> VkStreamDescriptorSurfaceCreateFlagsGGP
rotateL :: VkStreamDescriptorSurfaceCreateFlagsGGP
-> Int -> VkStreamDescriptorSurfaceCreateFlagsGGP
$crotateL :: VkStreamDescriptorSurfaceCreateFlagsGGP
-> Int -> VkStreamDescriptorSurfaceCreateFlagsGGP
unsafeShiftR :: VkStreamDescriptorSurfaceCreateFlagsGGP
-> Int -> VkStreamDescriptorSurfaceCreateFlagsGGP
$cunsafeShiftR :: VkStreamDescriptorSurfaceCreateFlagsGGP
-> Int -> VkStreamDescriptorSurfaceCreateFlagsGGP
shiftR :: VkStreamDescriptorSurfaceCreateFlagsGGP
-> Int -> VkStreamDescriptorSurfaceCreateFlagsGGP
$cshiftR :: VkStreamDescriptorSurfaceCreateFlagsGGP
-> Int -> VkStreamDescriptorSurfaceCreateFlagsGGP
unsafeShiftL :: VkStreamDescriptorSurfaceCreateFlagsGGP
-> Int -> VkStreamDescriptorSurfaceCreateFlagsGGP
$cunsafeShiftL :: VkStreamDescriptorSurfaceCreateFlagsGGP
-> Int -> VkStreamDescriptorSurfaceCreateFlagsGGP
shiftL :: VkStreamDescriptorSurfaceCreateFlagsGGP
-> Int -> VkStreamDescriptorSurfaceCreateFlagsGGP
$cshiftL :: VkStreamDescriptorSurfaceCreateFlagsGGP
-> Int -> VkStreamDescriptorSurfaceCreateFlagsGGP
isSigned :: VkStreamDescriptorSurfaceCreateFlagsGGP -> Bool
$cisSigned :: VkStreamDescriptorSurfaceCreateFlagsGGP -> Bool
bitSize :: VkStreamDescriptorSurfaceCreateFlagsGGP -> Int
$cbitSize :: VkStreamDescriptorSurfaceCreateFlagsGGP -> Int
bitSizeMaybe :: VkStreamDescriptorSurfaceCreateFlagsGGP -> Maybe Int
$cbitSizeMaybe :: VkStreamDescriptorSurfaceCreateFlagsGGP -> Maybe Int
testBit :: VkStreamDescriptorSurfaceCreateFlagsGGP -> Int -> Bool
$ctestBit :: VkStreamDescriptorSurfaceCreateFlagsGGP -> Int -> Bool
complementBit :: VkStreamDescriptorSurfaceCreateFlagsGGP
-> Int -> VkStreamDescriptorSurfaceCreateFlagsGGP
$ccomplementBit :: VkStreamDescriptorSurfaceCreateFlagsGGP
-> Int -> VkStreamDescriptorSurfaceCreateFlagsGGP
clearBit :: VkStreamDescriptorSurfaceCreateFlagsGGP
-> Int -> VkStreamDescriptorSurfaceCreateFlagsGGP
$cclearBit :: VkStreamDescriptorSurfaceCreateFlagsGGP
-> Int -> VkStreamDescriptorSurfaceCreateFlagsGGP
setBit :: VkStreamDescriptorSurfaceCreateFlagsGGP
-> Int -> VkStreamDescriptorSurfaceCreateFlagsGGP
$csetBit :: VkStreamDescriptorSurfaceCreateFlagsGGP
-> Int -> VkStreamDescriptorSurfaceCreateFlagsGGP
bit :: Int -> VkStreamDescriptorSurfaceCreateFlagsGGP
$cbit :: Int -> VkStreamDescriptorSurfaceCreateFlagsGGP
zeroBits :: VkStreamDescriptorSurfaceCreateFlagsGGP
$czeroBits :: VkStreamDescriptorSurfaceCreateFlagsGGP
rotate :: VkStreamDescriptorSurfaceCreateFlagsGGP
-> Int -> VkStreamDescriptorSurfaceCreateFlagsGGP
$crotate :: VkStreamDescriptorSurfaceCreateFlagsGGP
-> Int -> VkStreamDescriptorSurfaceCreateFlagsGGP
shift :: VkStreamDescriptorSurfaceCreateFlagsGGP
-> Int -> VkStreamDescriptorSurfaceCreateFlagsGGP
$cshift :: VkStreamDescriptorSurfaceCreateFlagsGGP
-> Int -> VkStreamDescriptorSurfaceCreateFlagsGGP
complement :: VkStreamDescriptorSurfaceCreateFlagsGGP
-> VkStreamDescriptorSurfaceCreateFlagsGGP
$ccomplement :: VkStreamDescriptorSurfaceCreateFlagsGGP
-> VkStreamDescriptorSurfaceCreateFlagsGGP
xor :: VkStreamDescriptorSurfaceCreateFlagsGGP
-> VkStreamDescriptorSurfaceCreateFlagsGGP
-> VkStreamDescriptorSurfaceCreateFlagsGGP
$cxor :: VkStreamDescriptorSurfaceCreateFlagsGGP
-> VkStreamDescriptorSurfaceCreateFlagsGGP
-> VkStreamDescriptorSurfaceCreateFlagsGGP
.|. :: VkStreamDescriptorSurfaceCreateFlagsGGP
-> VkStreamDescriptorSurfaceCreateFlagsGGP
-> VkStreamDescriptorSurfaceCreateFlagsGGP
$c.|. :: VkStreamDescriptorSurfaceCreateFlagsGGP
-> VkStreamDescriptorSurfaceCreateFlagsGGP
-> VkStreamDescriptorSurfaceCreateFlagsGGP
.&. :: VkStreamDescriptorSurfaceCreateFlagsGGP
-> VkStreamDescriptorSurfaceCreateFlagsGGP
-> VkStreamDescriptorSurfaceCreateFlagsGGP
$c.&. :: VkStreamDescriptorSurfaceCreateFlagsGGP
-> VkStreamDescriptorSurfaceCreateFlagsGGP
-> VkStreamDescriptorSurfaceCreateFlagsGGP
Bits, Bits VkStreamDescriptorSurfaceCreateFlagsGGP
Bits VkStreamDescriptorSurfaceCreateFlagsGGP
-> (VkStreamDescriptorSurfaceCreateFlagsGGP -> Int)
-> (VkStreamDescriptorSurfaceCreateFlagsGGP -> Int)
-> (VkStreamDescriptorSurfaceCreateFlagsGGP -> Int)
-> FiniteBits VkStreamDescriptorSurfaceCreateFlagsGGP
VkStreamDescriptorSurfaceCreateFlagsGGP -> Int
forall b.
Bits b -> (b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
countTrailingZeros :: VkStreamDescriptorSurfaceCreateFlagsGGP -> Int
$ccountTrailingZeros :: VkStreamDescriptorSurfaceCreateFlagsGGP -> Int
countLeadingZeros :: VkStreamDescriptorSurfaceCreateFlagsGGP -> Int
$ccountLeadingZeros :: VkStreamDescriptorSurfaceCreateFlagsGGP -> Int
finiteBitSize :: VkStreamDescriptorSurfaceCreateFlagsGGP -> Int
$cfiniteBitSize :: VkStreamDescriptorSurfaceCreateFlagsGGP -> Int
FiniteBits,
                                                            Ptr VkStreamDescriptorSurfaceCreateFlagsGGP
-> IO VkStreamDescriptorSurfaceCreateFlagsGGP
Ptr VkStreamDescriptorSurfaceCreateFlagsGGP
-> Int -> IO VkStreamDescriptorSurfaceCreateFlagsGGP
Ptr VkStreamDescriptorSurfaceCreateFlagsGGP
-> Int -> VkStreamDescriptorSurfaceCreateFlagsGGP -> IO ()
Ptr VkStreamDescriptorSurfaceCreateFlagsGGP
-> VkStreamDescriptorSurfaceCreateFlagsGGP -> IO ()
VkStreamDescriptorSurfaceCreateFlagsGGP -> Int
(VkStreamDescriptorSurfaceCreateFlagsGGP -> Int)
-> (VkStreamDescriptorSurfaceCreateFlagsGGP -> Int)
-> (Ptr VkStreamDescriptorSurfaceCreateFlagsGGP
    -> Int -> IO VkStreamDescriptorSurfaceCreateFlagsGGP)
-> (Ptr VkStreamDescriptorSurfaceCreateFlagsGGP
    -> Int -> VkStreamDescriptorSurfaceCreateFlagsGGP -> IO ())
-> (forall b.
    Ptr b -> Int -> IO VkStreamDescriptorSurfaceCreateFlagsGGP)
-> (forall b.
    Ptr b -> Int -> VkStreamDescriptorSurfaceCreateFlagsGGP -> IO ())
-> (Ptr VkStreamDescriptorSurfaceCreateFlagsGGP
    -> IO VkStreamDescriptorSurfaceCreateFlagsGGP)
-> (Ptr VkStreamDescriptorSurfaceCreateFlagsGGP
    -> VkStreamDescriptorSurfaceCreateFlagsGGP -> IO ())
-> Storable VkStreamDescriptorSurfaceCreateFlagsGGP
forall b.
Ptr b -> Int -> IO VkStreamDescriptorSurfaceCreateFlagsGGP
forall b.
Ptr b -> Int -> VkStreamDescriptorSurfaceCreateFlagsGGP -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr VkStreamDescriptorSurfaceCreateFlagsGGP
-> VkStreamDescriptorSurfaceCreateFlagsGGP -> IO ()
$cpoke :: Ptr VkStreamDescriptorSurfaceCreateFlagsGGP
-> VkStreamDescriptorSurfaceCreateFlagsGGP -> IO ()
peek :: Ptr VkStreamDescriptorSurfaceCreateFlagsGGP
-> IO VkStreamDescriptorSurfaceCreateFlagsGGP
$cpeek :: Ptr VkStreamDescriptorSurfaceCreateFlagsGGP
-> IO VkStreamDescriptorSurfaceCreateFlagsGGP
pokeByteOff :: forall b.
Ptr b -> Int -> VkStreamDescriptorSurfaceCreateFlagsGGP -> IO ()
$cpokeByteOff :: forall b.
Ptr b -> Int -> VkStreamDescriptorSurfaceCreateFlagsGGP -> IO ()
peekByteOff :: forall b.
Ptr b -> Int -> IO VkStreamDescriptorSurfaceCreateFlagsGGP
$cpeekByteOff :: forall b.
Ptr b -> Int -> IO VkStreamDescriptorSurfaceCreateFlagsGGP
pokeElemOff :: Ptr VkStreamDescriptorSurfaceCreateFlagsGGP
-> Int -> VkStreamDescriptorSurfaceCreateFlagsGGP -> IO ()
$cpokeElemOff :: Ptr VkStreamDescriptorSurfaceCreateFlagsGGP
-> Int -> VkStreamDescriptorSurfaceCreateFlagsGGP -> IO ()
peekElemOff :: Ptr VkStreamDescriptorSurfaceCreateFlagsGGP
-> Int -> IO VkStreamDescriptorSurfaceCreateFlagsGGP
$cpeekElemOff :: Ptr VkStreamDescriptorSurfaceCreateFlagsGGP
-> Int -> IO VkStreamDescriptorSurfaceCreateFlagsGGP
alignment :: VkStreamDescriptorSurfaceCreateFlagsGGP -> Int
$calignment :: VkStreamDescriptorSurfaceCreateFlagsGGP -> Int
sizeOf :: VkStreamDescriptorSurfaceCreateFlagsGGP -> Int
$csizeOf :: VkStreamDescriptorSurfaceCreateFlagsGGP -> Int
Storable)

instance Show VkStreamDescriptorSurfaceCreateFlagsGGP where
    {-# INLINE showsPrec #-}
    showsPrec :: Int -> VkStreamDescriptorSurfaceCreateFlagsGGP -> ShowS
showsPrec = (Int -> VkFlags -> ShowS)
-> Int -> VkStreamDescriptorSurfaceCreateFlagsGGP -> ShowS
coerce (Int -> VkFlags -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec :: Int -> VkFlags -> ShowS)

instance Read VkStreamDescriptorSurfaceCreateFlagsGGP where
    {-# INLINE readsPrec #-}
    readsPrec :: Int -> ReadS VkStreamDescriptorSurfaceCreateFlagsGGP
readsPrec = (Int -> ReadS VkFlags)
-> Int -> ReadS VkStreamDescriptorSurfaceCreateFlagsGGP
coerce (Int -> ReadS VkFlags
forall a. Read a => Int -> ReadS a
readsPrec :: Int -> ReadS VkFlags)

newtype VkValidationCacheCreateFlagsEXT = VkValidationCacheCreateFlagsEXT VkFlags
                                          deriving (VkValidationCacheCreateFlagsEXT
-> VkValidationCacheCreateFlagsEXT -> Bool
(VkValidationCacheCreateFlagsEXT
 -> VkValidationCacheCreateFlagsEXT -> Bool)
-> (VkValidationCacheCreateFlagsEXT
    -> VkValidationCacheCreateFlagsEXT -> Bool)
-> Eq VkValidationCacheCreateFlagsEXT
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VkValidationCacheCreateFlagsEXT
-> VkValidationCacheCreateFlagsEXT -> Bool
$c/= :: VkValidationCacheCreateFlagsEXT
-> VkValidationCacheCreateFlagsEXT -> Bool
== :: VkValidationCacheCreateFlagsEXT
-> VkValidationCacheCreateFlagsEXT -> Bool
$c== :: VkValidationCacheCreateFlagsEXT
-> VkValidationCacheCreateFlagsEXT -> Bool
Eq, Eq VkValidationCacheCreateFlagsEXT
Eq VkValidationCacheCreateFlagsEXT
-> (VkValidationCacheCreateFlagsEXT
    -> VkValidationCacheCreateFlagsEXT -> Ordering)
-> (VkValidationCacheCreateFlagsEXT
    -> VkValidationCacheCreateFlagsEXT -> Bool)
-> (VkValidationCacheCreateFlagsEXT
    -> VkValidationCacheCreateFlagsEXT -> Bool)
-> (VkValidationCacheCreateFlagsEXT
    -> VkValidationCacheCreateFlagsEXT -> Bool)
-> (VkValidationCacheCreateFlagsEXT
    -> VkValidationCacheCreateFlagsEXT -> Bool)
-> (VkValidationCacheCreateFlagsEXT
    -> VkValidationCacheCreateFlagsEXT
    -> VkValidationCacheCreateFlagsEXT)
-> (VkValidationCacheCreateFlagsEXT
    -> VkValidationCacheCreateFlagsEXT
    -> VkValidationCacheCreateFlagsEXT)
-> Ord VkValidationCacheCreateFlagsEXT
VkValidationCacheCreateFlagsEXT
-> VkValidationCacheCreateFlagsEXT -> Bool
VkValidationCacheCreateFlagsEXT
-> VkValidationCacheCreateFlagsEXT -> Ordering
VkValidationCacheCreateFlagsEXT
-> VkValidationCacheCreateFlagsEXT
-> VkValidationCacheCreateFlagsEXT
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: VkValidationCacheCreateFlagsEXT
-> VkValidationCacheCreateFlagsEXT
-> VkValidationCacheCreateFlagsEXT
$cmin :: VkValidationCacheCreateFlagsEXT
-> VkValidationCacheCreateFlagsEXT
-> VkValidationCacheCreateFlagsEXT
max :: VkValidationCacheCreateFlagsEXT
-> VkValidationCacheCreateFlagsEXT
-> VkValidationCacheCreateFlagsEXT
$cmax :: VkValidationCacheCreateFlagsEXT
-> VkValidationCacheCreateFlagsEXT
-> VkValidationCacheCreateFlagsEXT
>= :: VkValidationCacheCreateFlagsEXT
-> VkValidationCacheCreateFlagsEXT -> Bool
$c>= :: VkValidationCacheCreateFlagsEXT
-> VkValidationCacheCreateFlagsEXT -> Bool
> :: VkValidationCacheCreateFlagsEXT
-> VkValidationCacheCreateFlagsEXT -> Bool
$c> :: VkValidationCacheCreateFlagsEXT
-> VkValidationCacheCreateFlagsEXT -> Bool
<= :: VkValidationCacheCreateFlagsEXT
-> VkValidationCacheCreateFlagsEXT -> Bool
$c<= :: VkValidationCacheCreateFlagsEXT
-> VkValidationCacheCreateFlagsEXT -> Bool
< :: VkValidationCacheCreateFlagsEXT
-> VkValidationCacheCreateFlagsEXT -> Bool
$c< :: VkValidationCacheCreateFlagsEXT
-> VkValidationCacheCreateFlagsEXT -> Bool
compare :: VkValidationCacheCreateFlagsEXT
-> VkValidationCacheCreateFlagsEXT -> Ordering
$ccompare :: VkValidationCacheCreateFlagsEXT
-> VkValidationCacheCreateFlagsEXT -> Ordering
Ord, Int -> VkValidationCacheCreateFlagsEXT
VkValidationCacheCreateFlagsEXT -> Int
VkValidationCacheCreateFlagsEXT
-> [VkValidationCacheCreateFlagsEXT]
VkValidationCacheCreateFlagsEXT -> VkValidationCacheCreateFlagsEXT
VkValidationCacheCreateFlagsEXT
-> VkValidationCacheCreateFlagsEXT
-> [VkValidationCacheCreateFlagsEXT]
VkValidationCacheCreateFlagsEXT
-> VkValidationCacheCreateFlagsEXT
-> VkValidationCacheCreateFlagsEXT
-> [VkValidationCacheCreateFlagsEXT]
(VkValidationCacheCreateFlagsEXT
 -> VkValidationCacheCreateFlagsEXT)
-> (VkValidationCacheCreateFlagsEXT
    -> VkValidationCacheCreateFlagsEXT)
-> (Int -> VkValidationCacheCreateFlagsEXT)
-> (VkValidationCacheCreateFlagsEXT -> Int)
-> (VkValidationCacheCreateFlagsEXT
    -> [VkValidationCacheCreateFlagsEXT])
-> (VkValidationCacheCreateFlagsEXT
    -> VkValidationCacheCreateFlagsEXT
    -> [VkValidationCacheCreateFlagsEXT])
-> (VkValidationCacheCreateFlagsEXT
    -> VkValidationCacheCreateFlagsEXT
    -> [VkValidationCacheCreateFlagsEXT])
-> (VkValidationCacheCreateFlagsEXT
    -> VkValidationCacheCreateFlagsEXT
    -> VkValidationCacheCreateFlagsEXT
    -> [VkValidationCacheCreateFlagsEXT])
-> Enum VkValidationCacheCreateFlagsEXT
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: VkValidationCacheCreateFlagsEXT
-> VkValidationCacheCreateFlagsEXT
-> VkValidationCacheCreateFlagsEXT
-> [VkValidationCacheCreateFlagsEXT]
$cenumFromThenTo :: VkValidationCacheCreateFlagsEXT
-> VkValidationCacheCreateFlagsEXT
-> VkValidationCacheCreateFlagsEXT
-> [VkValidationCacheCreateFlagsEXT]
enumFromTo :: VkValidationCacheCreateFlagsEXT
-> VkValidationCacheCreateFlagsEXT
-> [VkValidationCacheCreateFlagsEXT]
$cenumFromTo :: VkValidationCacheCreateFlagsEXT
-> VkValidationCacheCreateFlagsEXT
-> [VkValidationCacheCreateFlagsEXT]
enumFromThen :: VkValidationCacheCreateFlagsEXT
-> VkValidationCacheCreateFlagsEXT
-> [VkValidationCacheCreateFlagsEXT]
$cenumFromThen :: VkValidationCacheCreateFlagsEXT
-> VkValidationCacheCreateFlagsEXT
-> [VkValidationCacheCreateFlagsEXT]
enumFrom :: VkValidationCacheCreateFlagsEXT
-> [VkValidationCacheCreateFlagsEXT]
$cenumFrom :: VkValidationCacheCreateFlagsEXT
-> [VkValidationCacheCreateFlagsEXT]
fromEnum :: VkValidationCacheCreateFlagsEXT -> Int
$cfromEnum :: VkValidationCacheCreateFlagsEXT -> Int
toEnum :: Int -> VkValidationCacheCreateFlagsEXT
$ctoEnum :: Int -> VkValidationCacheCreateFlagsEXT
pred :: VkValidationCacheCreateFlagsEXT -> VkValidationCacheCreateFlagsEXT
$cpred :: VkValidationCacheCreateFlagsEXT -> VkValidationCacheCreateFlagsEXT
succ :: VkValidationCacheCreateFlagsEXT -> VkValidationCacheCreateFlagsEXT
$csucc :: VkValidationCacheCreateFlagsEXT -> VkValidationCacheCreateFlagsEXT
Enum, Eq VkValidationCacheCreateFlagsEXT
VkValidationCacheCreateFlagsEXT
Eq VkValidationCacheCreateFlagsEXT
-> (VkValidationCacheCreateFlagsEXT
    -> VkValidationCacheCreateFlagsEXT
    -> VkValidationCacheCreateFlagsEXT)
-> (VkValidationCacheCreateFlagsEXT
    -> VkValidationCacheCreateFlagsEXT
    -> VkValidationCacheCreateFlagsEXT)
-> (VkValidationCacheCreateFlagsEXT
    -> VkValidationCacheCreateFlagsEXT
    -> VkValidationCacheCreateFlagsEXT)
-> (VkValidationCacheCreateFlagsEXT
    -> VkValidationCacheCreateFlagsEXT)
-> (VkValidationCacheCreateFlagsEXT
    -> Int -> VkValidationCacheCreateFlagsEXT)
-> (VkValidationCacheCreateFlagsEXT
    -> Int -> VkValidationCacheCreateFlagsEXT)
-> VkValidationCacheCreateFlagsEXT
-> (Int -> VkValidationCacheCreateFlagsEXT)
-> (VkValidationCacheCreateFlagsEXT
    -> Int -> VkValidationCacheCreateFlagsEXT)
-> (VkValidationCacheCreateFlagsEXT
    -> Int -> VkValidationCacheCreateFlagsEXT)
-> (VkValidationCacheCreateFlagsEXT
    -> Int -> VkValidationCacheCreateFlagsEXT)
-> (VkValidationCacheCreateFlagsEXT -> Int -> Bool)
-> (VkValidationCacheCreateFlagsEXT -> Maybe Int)
-> (VkValidationCacheCreateFlagsEXT -> Int)
-> (VkValidationCacheCreateFlagsEXT -> Bool)
-> (VkValidationCacheCreateFlagsEXT
    -> Int -> VkValidationCacheCreateFlagsEXT)
-> (VkValidationCacheCreateFlagsEXT
    -> Int -> VkValidationCacheCreateFlagsEXT)
-> (VkValidationCacheCreateFlagsEXT
    -> Int -> VkValidationCacheCreateFlagsEXT)
-> (VkValidationCacheCreateFlagsEXT
    -> Int -> VkValidationCacheCreateFlagsEXT)
-> (VkValidationCacheCreateFlagsEXT
    -> Int -> VkValidationCacheCreateFlagsEXT)
-> (VkValidationCacheCreateFlagsEXT
    -> Int -> VkValidationCacheCreateFlagsEXT)
-> (VkValidationCacheCreateFlagsEXT -> Int)
-> Bits VkValidationCacheCreateFlagsEXT
Int -> VkValidationCacheCreateFlagsEXT
VkValidationCacheCreateFlagsEXT -> Bool
VkValidationCacheCreateFlagsEXT -> Int
VkValidationCacheCreateFlagsEXT -> Maybe Int
VkValidationCacheCreateFlagsEXT -> VkValidationCacheCreateFlagsEXT
VkValidationCacheCreateFlagsEXT -> Int -> Bool
VkValidationCacheCreateFlagsEXT
-> Int -> VkValidationCacheCreateFlagsEXT
VkValidationCacheCreateFlagsEXT
-> VkValidationCacheCreateFlagsEXT
-> VkValidationCacheCreateFlagsEXT
forall a.
Eq a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
popCount :: VkValidationCacheCreateFlagsEXT -> Int
$cpopCount :: VkValidationCacheCreateFlagsEXT -> Int
rotateR :: VkValidationCacheCreateFlagsEXT
-> Int -> VkValidationCacheCreateFlagsEXT
$crotateR :: VkValidationCacheCreateFlagsEXT
-> Int -> VkValidationCacheCreateFlagsEXT
rotateL :: VkValidationCacheCreateFlagsEXT
-> Int -> VkValidationCacheCreateFlagsEXT
$crotateL :: VkValidationCacheCreateFlagsEXT
-> Int -> VkValidationCacheCreateFlagsEXT
unsafeShiftR :: VkValidationCacheCreateFlagsEXT
-> Int -> VkValidationCacheCreateFlagsEXT
$cunsafeShiftR :: VkValidationCacheCreateFlagsEXT
-> Int -> VkValidationCacheCreateFlagsEXT
shiftR :: VkValidationCacheCreateFlagsEXT
-> Int -> VkValidationCacheCreateFlagsEXT
$cshiftR :: VkValidationCacheCreateFlagsEXT
-> Int -> VkValidationCacheCreateFlagsEXT
unsafeShiftL :: VkValidationCacheCreateFlagsEXT
-> Int -> VkValidationCacheCreateFlagsEXT
$cunsafeShiftL :: VkValidationCacheCreateFlagsEXT
-> Int -> VkValidationCacheCreateFlagsEXT
shiftL :: VkValidationCacheCreateFlagsEXT
-> Int -> VkValidationCacheCreateFlagsEXT
$cshiftL :: VkValidationCacheCreateFlagsEXT
-> Int -> VkValidationCacheCreateFlagsEXT
isSigned :: VkValidationCacheCreateFlagsEXT -> Bool
$cisSigned :: VkValidationCacheCreateFlagsEXT -> Bool
bitSize :: VkValidationCacheCreateFlagsEXT -> Int
$cbitSize :: VkValidationCacheCreateFlagsEXT -> Int
bitSizeMaybe :: VkValidationCacheCreateFlagsEXT -> Maybe Int
$cbitSizeMaybe :: VkValidationCacheCreateFlagsEXT -> Maybe Int
testBit :: VkValidationCacheCreateFlagsEXT -> Int -> Bool
$ctestBit :: VkValidationCacheCreateFlagsEXT -> Int -> Bool
complementBit :: VkValidationCacheCreateFlagsEXT
-> Int -> VkValidationCacheCreateFlagsEXT
$ccomplementBit :: VkValidationCacheCreateFlagsEXT
-> Int -> VkValidationCacheCreateFlagsEXT
clearBit :: VkValidationCacheCreateFlagsEXT
-> Int -> VkValidationCacheCreateFlagsEXT
$cclearBit :: VkValidationCacheCreateFlagsEXT
-> Int -> VkValidationCacheCreateFlagsEXT
setBit :: VkValidationCacheCreateFlagsEXT
-> Int -> VkValidationCacheCreateFlagsEXT
$csetBit :: VkValidationCacheCreateFlagsEXT
-> Int -> VkValidationCacheCreateFlagsEXT
bit :: Int -> VkValidationCacheCreateFlagsEXT
$cbit :: Int -> VkValidationCacheCreateFlagsEXT
zeroBits :: VkValidationCacheCreateFlagsEXT
$czeroBits :: VkValidationCacheCreateFlagsEXT
rotate :: VkValidationCacheCreateFlagsEXT
-> Int -> VkValidationCacheCreateFlagsEXT
$crotate :: VkValidationCacheCreateFlagsEXT
-> Int -> VkValidationCacheCreateFlagsEXT
shift :: VkValidationCacheCreateFlagsEXT
-> Int -> VkValidationCacheCreateFlagsEXT
$cshift :: VkValidationCacheCreateFlagsEXT
-> Int -> VkValidationCacheCreateFlagsEXT
complement :: VkValidationCacheCreateFlagsEXT -> VkValidationCacheCreateFlagsEXT
$ccomplement :: VkValidationCacheCreateFlagsEXT -> VkValidationCacheCreateFlagsEXT
xor :: VkValidationCacheCreateFlagsEXT
-> VkValidationCacheCreateFlagsEXT
-> VkValidationCacheCreateFlagsEXT
$cxor :: VkValidationCacheCreateFlagsEXT
-> VkValidationCacheCreateFlagsEXT
-> VkValidationCacheCreateFlagsEXT
.|. :: VkValidationCacheCreateFlagsEXT
-> VkValidationCacheCreateFlagsEXT
-> VkValidationCacheCreateFlagsEXT
$c.|. :: VkValidationCacheCreateFlagsEXT
-> VkValidationCacheCreateFlagsEXT
-> VkValidationCacheCreateFlagsEXT
.&. :: VkValidationCacheCreateFlagsEXT
-> VkValidationCacheCreateFlagsEXT
-> VkValidationCacheCreateFlagsEXT
$c.&. :: VkValidationCacheCreateFlagsEXT
-> VkValidationCacheCreateFlagsEXT
-> VkValidationCacheCreateFlagsEXT
Bits, Bits VkValidationCacheCreateFlagsEXT
Bits VkValidationCacheCreateFlagsEXT
-> (VkValidationCacheCreateFlagsEXT -> Int)
-> (VkValidationCacheCreateFlagsEXT -> Int)
-> (VkValidationCacheCreateFlagsEXT -> Int)
-> FiniteBits VkValidationCacheCreateFlagsEXT
VkValidationCacheCreateFlagsEXT -> Int
forall b.
Bits b -> (b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
countTrailingZeros :: VkValidationCacheCreateFlagsEXT -> Int
$ccountTrailingZeros :: VkValidationCacheCreateFlagsEXT -> Int
countLeadingZeros :: VkValidationCacheCreateFlagsEXT -> Int
$ccountLeadingZeros :: VkValidationCacheCreateFlagsEXT -> Int
finiteBitSize :: VkValidationCacheCreateFlagsEXT -> Int
$cfiniteBitSize :: VkValidationCacheCreateFlagsEXT -> Int
FiniteBits, Ptr VkValidationCacheCreateFlagsEXT
-> IO VkValidationCacheCreateFlagsEXT
Ptr VkValidationCacheCreateFlagsEXT
-> Int -> IO VkValidationCacheCreateFlagsEXT
Ptr VkValidationCacheCreateFlagsEXT
-> Int -> VkValidationCacheCreateFlagsEXT -> IO ()
Ptr VkValidationCacheCreateFlagsEXT
-> VkValidationCacheCreateFlagsEXT -> IO ()
VkValidationCacheCreateFlagsEXT -> Int
(VkValidationCacheCreateFlagsEXT -> Int)
-> (VkValidationCacheCreateFlagsEXT -> Int)
-> (Ptr VkValidationCacheCreateFlagsEXT
    -> Int -> IO VkValidationCacheCreateFlagsEXT)
-> (Ptr VkValidationCacheCreateFlagsEXT
    -> Int -> VkValidationCacheCreateFlagsEXT -> IO ())
-> (forall b. Ptr b -> Int -> IO VkValidationCacheCreateFlagsEXT)
-> (forall b.
    Ptr b -> Int -> VkValidationCacheCreateFlagsEXT -> IO ())
-> (Ptr VkValidationCacheCreateFlagsEXT
    -> IO VkValidationCacheCreateFlagsEXT)
-> (Ptr VkValidationCacheCreateFlagsEXT
    -> VkValidationCacheCreateFlagsEXT -> IO ())
-> Storable VkValidationCacheCreateFlagsEXT
forall b. Ptr b -> Int -> IO VkValidationCacheCreateFlagsEXT
forall b. Ptr b -> Int -> VkValidationCacheCreateFlagsEXT -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr VkValidationCacheCreateFlagsEXT
-> VkValidationCacheCreateFlagsEXT -> IO ()
$cpoke :: Ptr VkValidationCacheCreateFlagsEXT
-> VkValidationCacheCreateFlagsEXT -> IO ()
peek :: Ptr VkValidationCacheCreateFlagsEXT
-> IO VkValidationCacheCreateFlagsEXT
$cpeek :: Ptr VkValidationCacheCreateFlagsEXT
-> IO VkValidationCacheCreateFlagsEXT
pokeByteOff :: forall b. Ptr b -> Int -> VkValidationCacheCreateFlagsEXT -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> VkValidationCacheCreateFlagsEXT -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO VkValidationCacheCreateFlagsEXT
$cpeekByteOff :: forall b. Ptr b -> Int -> IO VkValidationCacheCreateFlagsEXT
pokeElemOff :: Ptr VkValidationCacheCreateFlagsEXT
-> Int -> VkValidationCacheCreateFlagsEXT -> IO ()
$cpokeElemOff :: Ptr VkValidationCacheCreateFlagsEXT
-> Int -> VkValidationCacheCreateFlagsEXT -> IO ()
peekElemOff :: Ptr VkValidationCacheCreateFlagsEXT
-> Int -> IO VkValidationCacheCreateFlagsEXT
$cpeekElemOff :: Ptr VkValidationCacheCreateFlagsEXT
-> Int -> IO VkValidationCacheCreateFlagsEXT
alignment :: VkValidationCacheCreateFlagsEXT -> Int
$calignment :: VkValidationCacheCreateFlagsEXT -> Int
sizeOf :: VkValidationCacheCreateFlagsEXT -> Int
$csizeOf :: VkValidationCacheCreateFlagsEXT -> Int
Storable)

instance Show VkValidationCacheCreateFlagsEXT where
    {-# INLINE showsPrec #-}
    showsPrec :: Int -> VkValidationCacheCreateFlagsEXT -> ShowS
showsPrec = (Int -> VkFlags -> ShowS)
-> Int -> VkValidationCacheCreateFlagsEXT -> ShowS
coerce (Int -> VkFlags -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec :: Int -> VkFlags -> ShowS)

instance Read VkValidationCacheCreateFlagsEXT where
    {-# INLINE readsPrec #-}
    readsPrec :: Int -> ReadS VkValidationCacheCreateFlagsEXT
readsPrec = (Int -> ReadS VkFlags)
-> Int -> ReadS VkValidationCacheCreateFlagsEXT
coerce (Int -> ReadS VkFlags
forall a. Read a => Int -> ReadS a
readsPrec :: Int -> ReadS VkFlags)

newtype VkViSurfaceCreateFlagsNN = VkViSurfaceCreateFlagsNN VkFlags
                                   deriving (VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN -> Bool
(VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN -> Bool)
-> (VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN -> Bool)
-> Eq VkViSurfaceCreateFlagsNN
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN -> Bool
$c/= :: VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN -> Bool
== :: VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN -> Bool
$c== :: VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN -> Bool
Eq, Eq VkViSurfaceCreateFlagsNN
Eq VkViSurfaceCreateFlagsNN
-> (VkViSurfaceCreateFlagsNN
    -> VkViSurfaceCreateFlagsNN -> Ordering)
-> (VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN -> Bool)
-> (VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN -> Bool)
-> (VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN -> Bool)
-> (VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN -> Bool)
-> (VkViSurfaceCreateFlagsNN
    -> VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN)
-> (VkViSurfaceCreateFlagsNN
    -> VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN)
-> Ord VkViSurfaceCreateFlagsNN
VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN -> Bool
VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN -> Ordering
VkViSurfaceCreateFlagsNN
-> VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: VkViSurfaceCreateFlagsNN
-> VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN
$cmin :: VkViSurfaceCreateFlagsNN
-> VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN
max :: VkViSurfaceCreateFlagsNN
-> VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN
$cmax :: VkViSurfaceCreateFlagsNN
-> VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN
>= :: VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN -> Bool
$c>= :: VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN -> Bool
> :: VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN -> Bool
$c> :: VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN -> Bool
<= :: VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN -> Bool
$c<= :: VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN -> Bool
< :: VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN -> Bool
$c< :: VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN -> Bool
compare :: VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN -> Ordering
$ccompare :: VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN -> Ordering
Ord, Int -> VkViSurfaceCreateFlagsNN
VkViSurfaceCreateFlagsNN -> Int
VkViSurfaceCreateFlagsNN -> [VkViSurfaceCreateFlagsNN]
VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN
VkViSurfaceCreateFlagsNN
-> VkViSurfaceCreateFlagsNN -> [VkViSurfaceCreateFlagsNN]
VkViSurfaceCreateFlagsNN
-> VkViSurfaceCreateFlagsNN
-> VkViSurfaceCreateFlagsNN
-> [VkViSurfaceCreateFlagsNN]
(VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN)
-> (VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN)
-> (Int -> VkViSurfaceCreateFlagsNN)
-> (VkViSurfaceCreateFlagsNN -> Int)
-> (VkViSurfaceCreateFlagsNN -> [VkViSurfaceCreateFlagsNN])
-> (VkViSurfaceCreateFlagsNN
    -> VkViSurfaceCreateFlagsNN -> [VkViSurfaceCreateFlagsNN])
-> (VkViSurfaceCreateFlagsNN
    -> VkViSurfaceCreateFlagsNN -> [VkViSurfaceCreateFlagsNN])
-> (VkViSurfaceCreateFlagsNN
    -> VkViSurfaceCreateFlagsNN
    -> VkViSurfaceCreateFlagsNN
    -> [VkViSurfaceCreateFlagsNN])
-> Enum VkViSurfaceCreateFlagsNN
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: VkViSurfaceCreateFlagsNN
-> VkViSurfaceCreateFlagsNN
-> VkViSurfaceCreateFlagsNN
-> [VkViSurfaceCreateFlagsNN]
$cenumFromThenTo :: VkViSurfaceCreateFlagsNN
-> VkViSurfaceCreateFlagsNN
-> VkViSurfaceCreateFlagsNN
-> [VkViSurfaceCreateFlagsNN]
enumFromTo :: VkViSurfaceCreateFlagsNN
-> VkViSurfaceCreateFlagsNN -> [VkViSurfaceCreateFlagsNN]
$cenumFromTo :: VkViSurfaceCreateFlagsNN
-> VkViSurfaceCreateFlagsNN -> [VkViSurfaceCreateFlagsNN]
enumFromThen :: VkViSurfaceCreateFlagsNN
-> VkViSurfaceCreateFlagsNN -> [VkViSurfaceCreateFlagsNN]
$cenumFromThen :: VkViSurfaceCreateFlagsNN
-> VkViSurfaceCreateFlagsNN -> [VkViSurfaceCreateFlagsNN]
enumFrom :: VkViSurfaceCreateFlagsNN -> [VkViSurfaceCreateFlagsNN]
$cenumFrom :: VkViSurfaceCreateFlagsNN -> [VkViSurfaceCreateFlagsNN]
fromEnum :: VkViSurfaceCreateFlagsNN -> Int
$cfromEnum :: VkViSurfaceCreateFlagsNN -> Int
toEnum :: Int -> VkViSurfaceCreateFlagsNN
$ctoEnum :: Int -> VkViSurfaceCreateFlagsNN
pred :: VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN
$cpred :: VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN
succ :: VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN
$csucc :: VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN
Enum, Eq VkViSurfaceCreateFlagsNN
VkViSurfaceCreateFlagsNN
Eq VkViSurfaceCreateFlagsNN
-> (VkViSurfaceCreateFlagsNN
    -> VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN)
-> (VkViSurfaceCreateFlagsNN
    -> VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN)
-> (VkViSurfaceCreateFlagsNN
    -> VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN)
-> (VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN)
-> (VkViSurfaceCreateFlagsNN -> Int -> VkViSurfaceCreateFlagsNN)
-> (VkViSurfaceCreateFlagsNN -> Int -> VkViSurfaceCreateFlagsNN)
-> VkViSurfaceCreateFlagsNN
-> (Int -> VkViSurfaceCreateFlagsNN)
-> (VkViSurfaceCreateFlagsNN -> Int -> VkViSurfaceCreateFlagsNN)
-> (VkViSurfaceCreateFlagsNN -> Int -> VkViSurfaceCreateFlagsNN)
-> (VkViSurfaceCreateFlagsNN -> Int -> VkViSurfaceCreateFlagsNN)
-> (VkViSurfaceCreateFlagsNN -> Int -> Bool)
-> (VkViSurfaceCreateFlagsNN -> Maybe Int)
-> (VkViSurfaceCreateFlagsNN -> Int)
-> (VkViSurfaceCreateFlagsNN -> Bool)
-> (VkViSurfaceCreateFlagsNN -> Int -> VkViSurfaceCreateFlagsNN)
-> (VkViSurfaceCreateFlagsNN -> Int -> VkViSurfaceCreateFlagsNN)
-> (VkViSurfaceCreateFlagsNN -> Int -> VkViSurfaceCreateFlagsNN)
-> (VkViSurfaceCreateFlagsNN -> Int -> VkViSurfaceCreateFlagsNN)
-> (VkViSurfaceCreateFlagsNN -> Int -> VkViSurfaceCreateFlagsNN)
-> (VkViSurfaceCreateFlagsNN -> Int -> VkViSurfaceCreateFlagsNN)
-> (VkViSurfaceCreateFlagsNN -> Int)
-> Bits VkViSurfaceCreateFlagsNN
Int -> VkViSurfaceCreateFlagsNN
VkViSurfaceCreateFlagsNN -> Bool
VkViSurfaceCreateFlagsNN -> Int
VkViSurfaceCreateFlagsNN -> Maybe Int
VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN
VkViSurfaceCreateFlagsNN -> Int -> Bool
VkViSurfaceCreateFlagsNN -> Int -> VkViSurfaceCreateFlagsNN
VkViSurfaceCreateFlagsNN
-> VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN
forall a.
Eq a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
popCount :: VkViSurfaceCreateFlagsNN -> Int
$cpopCount :: VkViSurfaceCreateFlagsNN -> Int
rotateR :: VkViSurfaceCreateFlagsNN -> Int -> VkViSurfaceCreateFlagsNN
$crotateR :: VkViSurfaceCreateFlagsNN -> Int -> VkViSurfaceCreateFlagsNN
rotateL :: VkViSurfaceCreateFlagsNN -> Int -> VkViSurfaceCreateFlagsNN
$crotateL :: VkViSurfaceCreateFlagsNN -> Int -> VkViSurfaceCreateFlagsNN
unsafeShiftR :: VkViSurfaceCreateFlagsNN -> Int -> VkViSurfaceCreateFlagsNN
$cunsafeShiftR :: VkViSurfaceCreateFlagsNN -> Int -> VkViSurfaceCreateFlagsNN
shiftR :: VkViSurfaceCreateFlagsNN -> Int -> VkViSurfaceCreateFlagsNN
$cshiftR :: VkViSurfaceCreateFlagsNN -> Int -> VkViSurfaceCreateFlagsNN
unsafeShiftL :: VkViSurfaceCreateFlagsNN -> Int -> VkViSurfaceCreateFlagsNN
$cunsafeShiftL :: VkViSurfaceCreateFlagsNN -> Int -> VkViSurfaceCreateFlagsNN
shiftL :: VkViSurfaceCreateFlagsNN -> Int -> VkViSurfaceCreateFlagsNN
$cshiftL :: VkViSurfaceCreateFlagsNN -> Int -> VkViSurfaceCreateFlagsNN
isSigned :: VkViSurfaceCreateFlagsNN -> Bool
$cisSigned :: VkViSurfaceCreateFlagsNN -> Bool
bitSize :: VkViSurfaceCreateFlagsNN -> Int
$cbitSize :: VkViSurfaceCreateFlagsNN -> Int
bitSizeMaybe :: VkViSurfaceCreateFlagsNN -> Maybe Int
$cbitSizeMaybe :: VkViSurfaceCreateFlagsNN -> Maybe Int
testBit :: VkViSurfaceCreateFlagsNN -> Int -> Bool
$ctestBit :: VkViSurfaceCreateFlagsNN -> Int -> Bool
complementBit :: VkViSurfaceCreateFlagsNN -> Int -> VkViSurfaceCreateFlagsNN
$ccomplementBit :: VkViSurfaceCreateFlagsNN -> Int -> VkViSurfaceCreateFlagsNN
clearBit :: VkViSurfaceCreateFlagsNN -> Int -> VkViSurfaceCreateFlagsNN
$cclearBit :: VkViSurfaceCreateFlagsNN -> Int -> VkViSurfaceCreateFlagsNN
setBit :: VkViSurfaceCreateFlagsNN -> Int -> VkViSurfaceCreateFlagsNN
$csetBit :: VkViSurfaceCreateFlagsNN -> Int -> VkViSurfaceCreateFlagsNN
bit :: Int -> VkViSurfaceCreateFlagsNN
$cbit :: Int -> VkViSurfaceCreateFlagsNN
zeroBits :: VkViSurfaceCreateFlagsNN
$czeroBits :: VkViSurfaceCreateFlagsNN
rotate :: VkViSurfaceCreateFlagsNN -> Int -> VkViSurfaceCreateFlagsNN
$crotate :: VkViSurfaceCreateFlagsNN -> Int -> VkViSurfaceCreateFlagsNN
shift :: VkViSurfaceCreateFlagsNN -> Int -> VkViSurfaceCreateFlagsNN
$cshift :: VkViSurfaceCreateFlagsNN -> Int -> VkViSurfaceCreateFlagsNN
complement :: VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN
$ccomplement :: VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN
xor :: VkViSurfaceCreateFlagsNN
-> VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN
$cxor :: VkViSurfaceCreateFlagsNN
-> VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN
.|. :: VkViSurfaceCreateFlagsNN
-> VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN
$c.|. :: VkViSurfaceCreateFlagsNN
-> VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN
.&. :: VkViSurfaceCreateFlagsNN
-> VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN
$c.&. :: VkViSurfaceCreateFlagsNN
-> VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN
Bits, Bits VkViSurfaceCreateFlagsNN
Bits VkViSurfaceCreateFlagsNN
-> (VkViSurfaceCreateFlagsNN -> Int)
-> (VkViSurfaceCreateFlagsNN -> Int)
-> (VkViSurfaceCreateFlagsNN -> Int)
-> FiniteBits VkViSurfaceCreateFlagsNN
VkViSurfaceCreateFlagsNN -> Int
forall b.
Bits b -> (b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
countTrailingZeros :: VkViSurfaceCreateFlagsNN -> Int
$ccountTrailingZeros :: VkViSurfaceCreateFlagsNN -> Int
countLeadingZeros :: VkViSurfaceCreateFlagsNN -> Int
$ccountLeadingZeros :: VkViSurfaceCreateFlagsNN -> Int
finiteBitSize :: VkViSurfaceCreateFlagsNN -> Int
$cfiniteBitSize :: VkViSurfaceCreateFlagsNN -> Int
FiniteBits, Ptr VkViSurfaceCreateFlagsNN -> IO VkViSurfaceCreateFlagsNN
Ptr VkViSurfaceCreateFlagsNN -> Int -> IO VkViSurfaceCreateFlagsNN
Ptr VkViSurfaceCreateFlagsNN
-> Int -> VkViSurfaceCreateFlagsNN -> IO ()
Ptr VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN -> IO ()
VkViSurfaceCreateFlagsNN -> Int
(VkViSurfaceCreateFlagsNN -> Int)
-> (VkViSurfaceCreateFlagsNN -> Int)
-> (Ptr VkViSurfaceCreateFlagsNN
    -> Int -> IO VkViSurfaceCreateFlagsNN)
-> (Ptr VkViSurfaceCreateFlagsNN
    -> Int -> VkViSurfaceCreateFlagsNN -> IO ())
-> (forall b. Ptr b -> Int -> IO VkViSurfaceCreateFlagsNN)
-> (forall b. Ptr b -> Int -> VkViSurfaceCreateFlagsNN -> IO ())
-> (Ptr VkViSurfaceCreateFlagsNN -> IO VkViSurfaceCreateFlagsNN)
-> (Ptr VkViSurfaceCreateFlagsNN
    -> VkViSurfaceCreateFlagsNN -> IO ())
-> Storable VkViSurfaceCreateFlagsNN
forall b. Ptr b -> Int -> IO VkViSurfaceCreateFlagsNN
forall b. Ptr b -> Int -> VkViSurfaceCreateFlagsNN -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN -> IO ()
$cpoke :: Ptr VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN -> IO ()
peek :: Ptr VkViSurfaceCreateFlagsNN -> IO VkViSurfaceCreateFlagsNN
$cpeek :: Ptr VkViSurfaceCreateFlagsNN -> IO VkViSurfaceCreateFlagsNN
pokeByteOff :: forall b. Ptr b -> Int -> VkViSurfaceCreateFlagsNN -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> VkViSurfaceCreateFlagsNN -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO VkViSurfaceCreateFlagsNN
$cpeekByteOff :: forall b. Ptr b -> Int -> IO VkViSurfaceCreateFlagsNN
pokeElemOff :: Ptr VkViSurfaceCreateFlagsNN
-> Int -> VkViSurfaceCreateFlagsNN -> IO ()
$cpokeElemOff :: Ptr VkViSurfaceCreateFlagsNN
-> Int -> VkViSurfaceCreateFlagsNN -> IO ()
peekElemOff :: Ptr VkViSurfaceCreateFlagsNN -> Int -> IO VkViSurfaceCreateFlagsNN
$cpeekElemOff :: Ptr VkViSurfaceCreateFlagsNN -> Int -> IO VkViSurfaceCreateFlagsNN
alignment :: VkViSurfaceCreateFlagsNN -> Int
$calignment :: VkViSurfaceCreateFlagsNN -> Int
sizeOf :: VkViSurfaceCreateFlagsNN -> Int
$csizeOf :: VkViSurfaceCreateFlagsNN -> Int
Storable)

instance Show VkViSurfaceCreateFlagsNN where
    {-# INLINE showsPrec #-}
    showsPrec :: Int -> VkViSurfaceCreateFlagsNN -> ShowS
showsPrec = (Int -> VkFlags -> ShowS)
-> Int -> VkViSurfaceCreateFlagsNN -> ShowS
coerce (Int -> VkFlags -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec :: Int -> VkFlags -> ShowS)

instance Read VkViSurfaceCreateFlagsNN where
    {-# INLINE readsPrec #-}
    readsPrec :: Int -> ReadS VkViSurfaceCreateFlagsNN
readsPrec = (Int -> ReadS VkFlags) -> Int -> ReadS VkViSurfaceCreateFlagsNN
coerce (Int -> ReadS VkFlags
forall a. Read a => Int -> ReadS a
readsPrec :: Int -> ReadS VkFlags)

newtype VkWaylandSurfaceCreateFlagsKHR = VkWaylandSurfaceCreateFlagsKHR VkFlags
                                         deriving (VkWaylandSurfaceCreateFlagsKHR
-> VkWaylandSurfaceCreateFlagsKHR -> Bool
(VkWaylandSurfaceCreateFlagsKHR
 -> VkWaylandSurfaceCreateFlagsKHR -> Bool)
-> (VkWaylandSurfaceCreateFlagsKHR
    -> VkWaylandSurfaceCreateFlagsKHR -> Bool)
-> Eq VkWaylandSurfaceCreateFlagsKHR
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VkWaylandSurfaceCreateFlagsKHR
-> VkWaylandSurfaceCreateFlagsKHR -> Bool
$c/= :: VkWaylandSurfaceCreateFlagsKHR
-> VkWaylandSurfaceCreateFlagsKHR -> Bool
== :: VkWaylandSurfaceCreateFlagsKHR
-> VkWaylandSurfaceCreateFlagsKHR -> Bool
$c== :: VkWaylandSurfaceCreateFlagsKHR
-> VkWaylandSurfaceCreateFlagsKHR -> Bool
Eq, Eq VkWaylandSurfaceCreateFlagsKHR
Eq VkWaylandSurfaceCreateFlagsKHR
-> (VkWaylandSurfaceCreateFlagsKHR
    -> VkWaylandSurfaceCreateFlagsKHR -> Ordering)
-> (VkWaylandSurfaceCreateFlagsKHR
    -> VkWaylandSurfaceCreateFlagsKHR -> Bool)
-> (VkWaylandSurfaceCreateFlagsKHR
    -> VkWaylandSurfaceCreateFlagsKHR -> Bool)
-> (VkWaylandSurfaceCreateFlagsKHR
    -> VkWaylandSurfaceCreateFlagsKHR -> Bool)
-> (VkWaylandSurfaceCreateFlagsKHR
    -> VkWaylandSurfaceCreateFlagsKHR -> Bool)
-> (VkWaylandSurfaceCreateFlagsKHR
    -> VkWaylandSurfaceCreateFlagsKHR
    -> VkWaylandSurfaceCreateFlagsKHR)
-> (VkWaylandSurfaceCreateFlagsKHR
    -> VkWaylandSurfaceCreateFlagsKHR
    -> VkWaylandSurfaceCreateFlagsKHR)
-> Ord VkWaylandSurfaceCreateFlagsKHR
VkWaylandSurfaceCreateFlagsKHR
-> VkWaylandSurfaceCreateFlagsKHR -> Bool
VkWaylandSurfaceCreateFlagsKHR
-> VkWaylandSurfaceCreateFlagsKHR -> Ordering
VkWaylandSurfaceCreateFlagsKHR
-> VkWaylandSurfaceCreateFlagsKHR -> VkWaylandSurfaceCreateFlagsKHR
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: VkWaylandSurfaceCreateFlagsKHR
-> VkWaylandSurfaceCreateFlagsKHR -> VkWaylandSurfaceCreateFlagsKHR
$cmin :: VkWaylandSurfaceCreateFlagsKHR
-> VkWaylandSurfaceCreateFlagsKHR -> VkWaylandSurfaceCreateFlagsKHR
max :: VkWaylandSurfaceCreateFlagsKHR
-> VkWaylandSurfaceCreateFlagsKHR -> VkWaylandSurfaceCreateFlagsKHR
$cmax :: VkWaylandSurfaceCreateFlagsKHR
-> VkWaylandSurfaceCreateFlagsKHR -> VkWaylandSurfaceCreateFlagsKHR
>= :: VkWaylandSurfaceCreateFlagsKHR
-> VkWaylandSurfaceCreateFlagsKHR -> Bool
$c>= :: VkWaylandSurfaceCreateFlagsKHR
-> VkWaylandSurfaceCreateFlagsKHR -> Bool
> :: VkWaylandSurfaceCreateFlagsKHR
-> VkWaylandSurfaceCreateFlagsKHR -> Bool
$c> :: VkWaylandSurfaceCreateFlagsKHR
-> VkWaylandSurfaceCreateFlagsKHR -> Bool
<= :: VkWaylandSurfaceCreateFlagsKHR
-> VkWaylandSurfaceCreateFlagsKHR -> Bool
$c<= :: VkWaylandSurfaceCreateFlagsKHR
-> VkWaylandSurfaceCreateFlagsKHR -> Bool
< :: VkWaylandSurfaceCreateFlagsKHR
-> VkWaylandSurfaceCreateFlagsKHR -> Bool
$c< :: VkWaylandSurfaceCreateFlagsKHR
-> VkWaylandSurfaceCreateFlagsKHR -> Bool
compare :: VkWaylandSurfaceCreateFlagsKHR
-> VkWaylandSurfaceCreateFlagsKHR -> Ordering
$ccompare :: VkWaylandSurfaceCreateFlagsKHR
-> VkWaylandSurfaceCreateFlagsKHR -> Ordering
Ord, Int -> VkWaylandSurfaceCreateFlagsKHR
VkWaylandSurfaceCreateFlagsKHR -> Int
VkWaylandSurfaceCreateFlagsKHR -> [VkWaylandSurfaceCreateFlagsKHR]
VkWaylandSurfaceCreateFlagsKHR -> VkWaylandSurfaceCreateFlagsKHR
VkWaylandSurfaceCreateFlagsKHR
-> VkWaylandSurfaceCreateFlagsKHR
-> [VkWaylandSurfaceCreateFlagsKHR]
VkWaylandSurfaceCreateFlagsKHR
-> VkWaylandSurfaceCreateFlagsKHR
-> VkWaylandSurfaceCreateFlagsKHR
-> [VkWaylandSurfaceCreateFlagsKHR]
(VkWaylandSurfaceCreateFlagsKHR -> VkWaylandSurfaceCreateFlagsKHR)
-> (VkWaylandSurfaceCreateFlagsKHR
    -> VkWaylandSurfaceCreateFlagsKHR)
-> (Int -> VkWaylandSurfaceCreateFlagsKHR)
-> (VkWaylandSurfaceCreateFlagsKHR -> Int)
-> (VkWaylandSurfaceCreateFlagsKHR
    -> [VkWaylandSurfaceCreateFlagsKHR])
-> (VkWaylandSurfaceCreateFlagsKHR
    -> VkWaylandSurfaceCreateFlagsKHR
    -> [VkWaylandSurfaceCreateFlagsKHR])
-> (VkWaylandSurfaceCreateFlagsKHR
    -> VkWaylandSurfaceCreateFlagsKHR
    -> [VkWaylandSurfaceCreateFlagsKHR])
-> (VkWaylandSurfaceCreateFlagsKHR
    -> VkWaylandSurfaceCreateFlagsKHR
    -> VkWaylandSurfaceCreateFlagsKHR
    -> [VkWaylandSurfaceCreateFlagsKHR])
-> Enum VkWaylandSurfaceCreateFlagsKHR
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: VkWaylandSurfaceCreateFlagsKHR
-> VkWaylandSurfaceCreateFlagsKHR
-> VkWaylandSurfaceCreateFlagsKHR
-> [VkWaylandSurfaceCreateFlagsKHR]
$cenumFromThenTo :: VkWaylandSurfaceCreateFlagsKHR
-> VkWaylandSurfaceCreateFlagsKHR
-> VkWaylandSurfaceCreateFlagsKHR
-> [VkWaylandSurfaceCreateFlagsKHR]
enumFromTo :: VkWaylandSurfaceCreateFlagsKHR
-> VkWaylandSurfaceCreateFlagsKHR
-> [VkWaylandSurfaceCreateFlagsKHR]
$cenumFromTo :: VkWaylandSurfaceCreateFlagsKHR
-> VkWaylandSurfaceCreateFlagsKHR
-> [VkWaylandSurfaceCreateFlagsKHR]
enumFromThen :: VkWaylandSurfaceCreateFlagsKHR
-> VkWaylandSurfaceCreateFlagsKHR
-> [VkWaylandSurfaceCreateFlagsKHR]
$cenumFromThen :: VkWaylandSurfaceCreateFlagsKHR
-> VkWaylandSurfaceCreateFlagsKHR
-> [VkWaylandSurfaceCreateFlagsKHR]
enumFrom :: VkWaylandSurfaceCreateFlagsKHR -> [VkWaylandSurfaceCreateFlagsKHR]
$cenumFrom :: VkWaylandSurfaceCreateFlagsKHR -> [VkWaylandSurfaceCreateFlagsKHR]
fromEnum :: VkWaylandSurfaceCreateFlagsKHR -> Int
$cfromEnum :: VkWaylandSurfaceCreateFlagsKHR -> Int
toEnum :: Int -> VkWaylandSurfaceCreateFlagsKHR
$ctoEnum :: Int -> VkWaylandSurfaceCreateFlagsKHR
pred :: VkWaylandSurfaceCreateFlagsKHR -> VkWaylandSurfaceCreateFlagsKHR
$cpred :: VkWaylandSurfaceCreateFlagsKHR -> VkWaylandSurfaceCreateFlagsKHR
succ :: VkWaylandSurfaceCreateFlagsKHR -> VkWaylandSurfaceCreateFlagsKHR
$csucc :: VkWaylandSurfaceCreateFlagsKHR -> VkWaylandSurfaceCreateFlagsKHR
Enum, Eq VkWaylandSurfaceCreateFlagsKHR
VkWaylandSurfaceCreateFlagsKHR
Eq VkWaylandSurfaceCreateFlagsKHR
-> (VkWaylandSurfaceCreateFlagsKHR
    -> VkWaylandSurfaceCreateFlagsKHR
    -> VkWaylandSurfaceCreateFlagsKHR)
-> (VkWaylandSurfaceCreateFlagsKHR
    -> VkWaylandSurfaceCreateFlagsKHR
    -> VkWaylandSurfaceCreateFlagsKHR)
-> (VkWaylandSurfaceCreateFlagsKHR
    -> VkWaylandSurfaceCreateFlagsKHR
    -> VkWaylandSurfaceCreateFlagsKHR)
-> (VkWaylandSurfaceCreateFlagsKHR
    -> VkWaylandSurfaceCreateFlagsKHR)
-> (VkWaylandSurfaceCreateFlagsKHR
    -> Int -> VkWaylandSurfaceCreateFlagsKHR)
-> (VkWaylandSurfaceCreateFlagsKHR
    -> Int -> VkWaylandSurfaceCreateFlagsKHR)
-> VkWaylandSurfaceCreateFlagsKHR
-> (Int -> VkWaylandSurfaceCreateFlagsKHR)
-> (VkWaylandSurfaceCreateFlagsKHR
    -> Int -> VkWaylandSurfaceCreateFlagsKHR)
-> (VkWaylandSurfaceCreateFlagsKHR
    -> Int -> VkWaylandSurfaceCreateFlagsKHR)
-> (VkWaylandSurfaceCreateFlagsKHR
    -> Int -> VkWaylandSurfaceCreateFlagsKHR)
-> (VkWaylandSurfaceCreateFlagsKHR -> Int -> Bool)
-> (VkWaylandSurfaceCreateFlagsKHR -> Maybe Int)
-> (VkWaylandSurfaceCreateFlagsKHR -> Int)
-> (VkWaylandSurfaceCreateFlagsKHR -> Bool)
-> (VkWaylandSurfaceCreateFlagsKHR
    -> Int -> VkWaylandSurfaceCreateFlagsKHR)
-> (VkWaylandSurfaceCreateFlagsKHR
    -> Int -> VkWaylandSurfaceCreateFlagsKHR)
-> (VkWaylandSurfaceCreateFlagsKHR
    -> Int -> VkWaylandSurfaceCreateFlagsKHR)
-> (VkWaylandSurfaceCreateFlagsKHR
    -> Int -> VkWaylandSurfaceCreateFlagsKHR)
-> (VkWaylandSurfaceCreateFlagsKHR
    -> Int -> VkWaylandSurfaceCreateFlagsKHR)
-> (VkWaylandSurfaceCreateFlagsKHR
    -> Int -> VkWaylandSurfaceCreateFlagsKHR)
-> (VkWaylandSurfaceCreateFlagsKHR -> Int)
-> Bits VkWaylandSurfaceCreateFlagsKHR
Int -> VkWaylandSurfaceCreateFlagsKHR
VkWaylandSurfaceCreateFlagsKHR -> Bool
VkWaylandSurfaceCreateFlagsKHR -> Int
VkWaylandSurfaceCreateFlagsKHR -> Maybe Int
VkWaylandSurfaceCreateFlagsKHR -> VkWaylandSurfaceCreateFlagsKHR
VkWaylandSurfaceCreateFlagsKHR -> Int -> Bool
VkWaylandSurfaceCreateFlagsKHR
-> Int -> VkWaylandSurfaceCreateFlagsKHR
VkWaylandSurfaceCreateFlagsKHR
-> VkWaylandSurfaceCreateFlagsKHR -> VkWaylandSurfaceCreateFlagsKHR
forall a.
Eq a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
popCount :: VkWaylandSurfaceCreateFlagsKHR -> Int
$cpopCount :: VkWaylandSurfaceCreateFlagsKHR -> Int
rotateR :: VkWaylandSurfaceCreateFlagsKHR
-> Int -> VkWaylandSurfaceCreateFlagsKHR
$crotateR :: VkWaylandSurfaceCreateFlagsKHR
-> Int -> VkWaylandSurfaceCreateFlagsKHR
rotateL :: VkWaylandSurfaceCreateFlagsKHR
-> Int -> VkWaylandSurfaceCreateFlagsKHR
$crotateL :: VkWaylandSurfaceCreateFlagsKHR
-> Int -> VkWaylandSurfaceCreateFlagsKHR
unsafeShiftR :: VkWaylandSurfaceCreateFlagsKHR
-> Int -> VkWaylandSurfaceCreateFlagsKHR
$cunsafeShiftR :: VkWaylandSurfaceCreateFlagsKHR
-> Int -> VkWaylandSurfaceCreateFlagsKHR
shiftR :: VkWaylandSurfaceCreateFlagsKHR
-> Int -> VkWaylandSurfaceCreateFlagsKHR
$cshiftR :: VkWaylandSurfaceCreateFlagsKHR
-> Int -> VkWaylandSurfaceCreateFlagsKHR
unsafeShiftL :: VkWaylandSurfaceCreateFlagsKHR
-> Int -> VkWaylandSurfaceCreateFlagsKHR
$cunsafeShiftL :: VkWaylandSurfaceCreateFlagsKHR
-> Int -> VkWaylandSurfaceCreateFlagsKHR
shiftL :: VkWaylandSurfaceCreateFlagsKHR
-> Int -> VkWaylandSurfaceCreateFlagsKHR
$cshiftL :: VkWaylandSurfaceCreateFlagsKHR
-> Int -> VkWaylandSurfaceCreateFlagsKHR
isSigned :: VkWaylandSurfaceCreateFlagsKHR -> Bool
$cisSigned :: VkWaylandSurfaceCreateFlagsKHR -> Bool
bitSize :: VkWaylandSurfaceCreateFlagsKHR -> Int
$cbitSize :: VkWaylandSurfaceCreateFlagsKHR -> Int
bitSizeMaybe :: VkWaylandSurfaceCreateFlagsKHR -> Maybe Int
$cbitSizeMaybe :: VkWaylandSurfaceCreateFlagsKHR -> Maybe Int
testBit :: VkWaylandSurfaceCreateFlagsKHR -> Int -> Bool
$ctestBit :: VkWaylandSurfaceCreateFlagsKHR -> Int -> Bool
complementBit :: VkWaylandSurfaceCreateFlagsKHR
-> Int -> VkWaylandSurfaceCreateFlagsKHR
$ccomplementBit :: VkWaylandSurfaceCreateFlagsKHR
-> Int -> VkWaylandSurfaceCreateFlagsKHR
clearBit :: VkWaylandSurfaceCreateFlagsKHR
-> Int -> VkWaylandSurfaceCreateFlagsKHR
$cclearBit :: VkWaylandSurfaceCreateFlagsKHR
-> Int -> VkWaylandSurfaceCreateFlagsKHR
setBit :: VkWaylandSurfaceCreateFlagsKHR
-> Int -> VkWaylandSurfaceCreateFlagsKHR
$csetBit :: VkWaylandSurfaceCreateFlagsKHR
-> Int -> VkWaylandSurfaceCreateFlagsKHR
bit :: Int -> VkWaylandSurfaceCreateFlagsKHR
$cbit :: Int -> VkWaylandSurfaceCreateFlagsKHR
zeroBits :: VkWaylandSurfaceCreateFlagsKHR
$czeroBits :: VkWaylandSurfaceCreateFlagsKHR
rotate :: VkWaylandSurfaceCreateFlagsKHR
-> Int -> VkWaylandSurfaceCreateFlagsKHR
$crotate :: VkWaylandSurfaceCreateFlagsKHR
-> Int -> VkWaylandSurfaceCreateFlagsKHR
shift :: VkWaylandSurfaceCreateFlagsKHR
-> Int -> VkWaylandSurfaceCreateFlagsKHR
$cshift :: VkWaylandSurfaceCreateFlagsKHR
-> Int -> VkWaylandSurfaceCreateFlagsKHR
complement :: VkWaylandSurfaceCreateFlagsKHR -> VkWaylandSurfaceCreateFlagsKHR
$ccomplement :: VkWaylandSurfaceCreateFlagsKHR -> VkWaylandSurfaceCreateFlagsKHR
xor :: VkWaylandSurfaceCreateFlagsKHR
-> VkWaylandSurfaceCreateFlagsKHR -> VkWaylandSurfaceCreateFlagsKHR
$cxor :: VkWaylandSurfaceCreateFlagsKHR
-> VkWaylandSurfaceCreateFlagsKHR -> VkWaylandSurfaceCreateFlagsKHR
.|. :: VkWaylandSurfaceCreateFlagsKHR
-> VkWaylandSurfaceCreateFlagsKHR -> VkWaylandSurfaceCreateFlagsKHR
$c.|. :: VkWaylandSurfaceCreateFlagsKHR
-> VkWaylandSurfaceCreateFlagsKHR -> VkWaylandSurfaceCreateFlagsKHR
.&. :: VkWaylandSurfaceCreateFlagsKHR
-> VkWaylandSurfaceCreateFlagsKHR -> VkWaylandSurfaceCreateFlagsKHR
$c.&. :: VkWaylandSurfaceCreateFlagsKHR
-> VkWaylandSurfaceCreateFlagsKHR -> VkWaylandSurfaceCreateFlagsKHR
Bits, Bits VkWaylandSurfaceCreateFlagsKHR
Bits VkWaylandSurfaceCreateFlagsKHR
-> (VkWaylandSurfaceCreateFlagsKHR -> Int)
-> (VkWaylandSurfaceCreateFlagsKHR -> Int)
-> (VkWaylandSurfaceCreateFlagsKHR -> Int)
-> FiniteBits VkWaylandSurfaceCreateFlagsKHR
VkWaylandSurfaceCreateFlagsKHR -> Int
forall b.
Bits b -> (b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
countTrailingZeros :: VkWaylandSurfaceCreateFlagsKHR -> Int
$ccountTrailingZeros :: VkWaylandSurfaceCreateFlagsKHR -> Int
countLeadingZeros :: VkWaylandSurfaceCreateFlagsKHR -> Int
$ccountLeadingZeros :: VkWaylandSurfaceCreateFlagsKHR -> Int
finiteBitSize :: VkWaylandSurfaceCreateFlagsKHR -> Int
$cfiniteBitSize :: VkWaylandSurfaceCreateFlagsKHR -> Int
FiniteBits, Ptr VkWaylandSurfaceCreateFlagsKHR
-> IO VkWaylandSurfaceCreateFlagsKHR
Ptr VkWaylandSurfaceCreateFlagsKHR
-> Int -> IO VkWaylandSurfaceCreateFlagsKHR
Ptr VkWaylandSurfaceCreateFlagsKHR
-> Int -> VkWaylandSurfaceCreateFlagsKHR -> IO ()
Ptr VkWaylandSurfaceCreateFlagsKHR
-> VkWaylandSurfaceCreateFlagsKHR -> IO ()
VkWaylandSurfaceCreateFlagsKHR -> Int
(VkWaylandSurfaceCreateFlagsKHR -> Int)
-> (VkWaylandSurfaceCreateFlagsKHR -> Int)
-> (Ptr VkWaylandSurfaceCreateFlagsKHR
    -> Int -> IO VkWaylandSurfaceCreateFlagsKHR)
-> (Ptr VkWaylandSurfaceCreateFlagsKHR
    -> Int -> VkWaylandSurfaceCreateFlagsKHR -> IO ())
-> (forall b. Ptr b -> Int -> IO VkWaylandSurfaceCreateFlagsKHR)
-> (forall b.
    Ptr b -> Int -> VkWaylandSurfaceCreateFlagsKHR -> IO ())
-> (Ptr VkWaylandSurfaceCreateFlagsKHR
    -> IO VkWaylandSurfaceCreateFlagsKHR)
-> (Ptr VkWaylandSurfaceCreateFlagsKHR
    -> VkWaylandSurfaceCreateFlagsKHR -> IO ())
-> Storable VkWaylandSurfaceCreateFlagsKHR
forall b. Ptr b -> Int -> IO VkWaylandSurfaceCreateFlagsKHR
forall b. Ptr b -> Int -> VkWaylandSurfaceCreateFlagsKHR -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr VkWaylandSurfaceCreateFlagsKHR
-> VkWaylandSurfaceCreateFlagsKHR -> IO ()
$cpoke :: Ptr VkWaylandSurfaceCreateFlagsKHR
-> VkWaylandSurfaceCreateFlagsKHR -> IO ()
peek :: Ptr VkWaylandSurfaceCreateFlagsKHR
-> IO VkWaylandSurfaceCreateFlagsKHR
$cpeek :: Ptr VkWaylandSurfaceCreateFlagsKHR
-> IO VkWaylandSurfaceCreateFlagsKHR
pokeByteOff :: forall b. Ptr b -> Int -> VkWaylandSurfaceCreateFlagsKHR -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> VkWaylandSurfaceCreateFlagsKHR -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO VkWaylandSurfaceCreateFlagsKHR
$cpeekByteOff :: forall b. Ptr b -> Int -> IO VkWaylandSurfaceCreateFlagsKHR
pokeElemOff :: Ptr VkWaylandSurfaceCreateFlagsKHR
-> Int -> VkWaylandSurfaceCreateFlagsKHR -> IO ()
$cpokeElemOff :: Ptr VkWaylandSurfaceCreateFlagsKHR
-> Int -> VkWaylandSurfaceCreateFlagsKHR -> IO ()
peekElemOff :: Ptr VkWaylandSurfaceCreateFlagsKHR
-> Int -> IO VkWaylandSurfaceCreateFlagsKHR
$cpeekElemOff :: Ptr VkWaylandSurfaceCreateFlagsKHR
-> Int -> IO VkWaylandSurfaceCreateFlagsKHR
alignment :: VkWaylandSurfaceCreateFlagsKHR -> Int
$calignment :: VkWaylandSurfaceCreateFlagsKHR -> Int
sizeOf :: VkWaylandSurfaceCreateFlagsKHR -> Int
$csizeOf :: VkWaylandSurfaceCreateFlagsKHR -> Int
Storable)

instance Show VkWaylandSurfaceCreateFlagsKHR where
    {-# INLINE showsPrec #-}
    showsPrec :: Int -> VkWaylandSurfaceCreateFlagsKHR -> ShowS
showsPrec = (Int -> VkFlags -> ShowS)
-> Int -> VkWaylandSurfaceCreateFlagsKHR -> ShowS
coerce (Int -> VkFlags -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec :: Int -> VkFlags -> ShowS)

instance Read VkWaylandSurfaceCreateFlagsKHR where
    {-# INLINE readsPrec #-}
    readsPrec :: Int -> ReadS VkWaylandSurfaceCreateFlagsKHR
readsPrec = (Int -> ReadS VkFlags)
-> Int -> ReadS VkWaylandSurfaceCreateFlagsKHR
coerce (Int -> ReadS VkFlags
forall a. Read a => Int -> ReadS a
readsPrec :: Int -> ReadS VkFlags)

newtype VkWin32SurfaceCreateFlagsKHR = VkWin32SurfaceCreateFlagsKHR VkFlags
                                       deriving (VkWin32SurfaceCreateFlagsKHR
-> VkWin32SurfaceCreateFlagsKHR -> Bool
(VkWin32SurfaceCreateFlagsKHR
 -> VkWin32SurfaceCreateFlagsKHR -> Bool)
-> (VkWin32SurfaceCreateFlagsKHR
    -> VkWin32SurfaceCreateFlagsKHR -> Bool)
-> Eq VkWin32SurfaceCreateFlagsKHR
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VkWin32SurfaceCreateFlagsKHR
-> VkWin32SurfaceCreateFlagsKHR -> Bool
$c/= :: VkWin32SurfaceCreateFlagsKHR
-> VkWin32SurfaceCreateFlagsKHR -> Bool
== :: VkWin32SurfaceCreateFlagsKHR
-> VkWin32SurfaceCreateFlagsKHR -> Bool
$c== :: VkWin32SurfaceCreateFlagsKHR
-> VkWin32SurfaceCreateFlagsKHR -> Bool
Eq, Eq VkWin32SurfaceCreateFlagsKHR
Eq VkWin32SurfaceCreateFlagsKHR
-> (VkWin32SurfaceCreateFlagsKHR
    -> VkWin32SurfaceCreateFlagsKHR -> Ordering)
-> (VkWin32SurfaceCreateFlagsKHR
    -> VkWin32SurfaceCreateFlagsKHR -> Bool)
-> (VkWin32SurfaceCreateFlagsKHR
    -> VkWin32SurfaceCreateFlagsKHR -> Bool)
-> (VkWin32SurfaceCreateFlagsKHR
    -> VkWin32SurfaceCreateFlagsKHR -> Bool)
-> (VkWin32SurfaceCreateFlagsKHR
    -> VkWin32SurfaceCreateFlagsKHR -> Bool)
-> (VkWin32SurfaceCreateFlagsKHR
    -> VkWin32SurfaceCreateFlagsKHR -> VkWin32SurfaceCreateFlagsKHR)
-> (VkWin32SurfaceCreateFlagsKHR
    -> VkWin32SurfaceCreateFlagsKHR -> VkWin32SurfaceCreateFlagsKHR)
-> Ord VkWin32SurfaceCreateFlagsKHR
VkWin32SurfaceCreateFlagsKHR
-> VkWin32SurfaceCreateFlagsKHR -> Bool
VkWin32SurfaceCreateFlagsKHR
-> VkWin32SurfaceCreateFlagsKHR -> Ordering
VkWin32SurfaceCreateFlagsKHR
-> VkWin32SurfaceCreateFlagsKHR -> VkWin32SurfaceCreateFlagsKHR
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: VkWin32SurfaceCreateFlagsKHR
-> VkWin32SurfaceCreateFlagsKHR -> VkWin32SurfaceCreateFlagsKHR
$cmin :: VkWin32SurfaceCreateFlagsKHR
-> VkWin32SurfaceCreateFlagsKHR -> VkWin32SurfaceCreateFlagsKHR
max :: VkWin32SurfaceCreateFlagsKHR
-> VkWin32SurfaceCreateFlagsKHR -> VkWin32SurfaceCreateFlagsKHR
$cmax :: VkWin32SurfaceCreateFlagsKHR
-> VkWin32SurfaceCreateFlagsKHR -> VkWin32SurfaceCreateFlagsKHR
>= :: VkWin32SurfaceCreateFlagsKHR
-> VkWin32SurfaceCreateFlagsKHR -> Bool
$c>= :: VkWin32SurfaceCreateFlagsKHR
-> VkWin32SurfaceCreateFlagsKHR -> Bool
> :: VkWin32SurfaceCreateFlagsKHR
-> VkWin32SurfaceCreateFlagsKHR -> Bool
$c> :: VkWin32SurfaceCreateFlagsKHR
-> VkWin32SurfaceCreateFlagsKHR -> Bool
<= :: VkWin32SurfaceCreateFlagsKHR
-> VkWin32SurfaceCreateFlagsKHR -> Bool
$c<= :: VkWin32SurfaceCreateFlagsKHR
-> VkWin32SurfaceCreateFlagsKHR -> Bool
< :: VkWin32SurfaceCreateFlagsKHR
-> VkWin32SurfaceCreateFlagsKHR -> Bool
$c< :: VkWin32SurfaceCreateFlagsKHR
-> VkWin32SurfaceCreateFlagsKHR -> Bool
compare :: VkWin32SurfaceCreateFlagsKHR
-> VkWin32SurfaceCreateFlagsKHR -> Ordering
$ccompare :: VkWin32SurfaceCreateFlagsKHR
-> VkWin32SurfaceCreateFlagsKHR -> Ordering
Ord, Int -> VkWin32SurfaceCreateFlagsKHR
VkWin32SurfaceCreateFlagsKHR -> Int
VkWin32SurfaceCreateFlagsKHR -> [VkWin32SurfaceCreateFlagsKHR]
VkWin32SurfaceCreateFlagsKHR -> VkWin32SurfaceCreateFlagsKHR
VkWin32SurfaceCreateFlagsKHR
-> VkWin32SurfaceCreateFlagsKHR -> [VkWin32SurfaceCreateFlagsKHR]
VkWin32SurfaceCreateFlagsKHR
-> VkWin32SurfaceCreateFlagsKHR
-> VkWin32SurfaceCreateFlagsKHR
-> [VkWin32SurfaceCreateFlagsKHR]
(VkWin32SurfaceCreateFlagsKHR -> VkWin32SurfaceCreateFlagsKHR)
-> (VkWin32SurfaceCreateFlagsKHR -> VkWin32SurfaceCreateFlagsKHR)
-> (Int -> VkWin32SurfaceCreateFlagsKHR)
-> (VkWin32SurfaceCreateFlagsKHR -> Int)
-> (VkWin32SurfaceCreateFlagsKHR -> [VkWin32SurfaceCreateFlagsKHR])
-> (VkWin32SurfaceCreateFlagsKHR
    -> VkWin32SurfaceCreateFlagsKHR -> [VkWin32SurfaceCreateFlagsKHR])
-> (VkWin32SurfaceCreateFlagsKHR
    -> VkWin32SurfaceCreateFlagsKHR -> [VkWin32SurfaceCreateFlagsKHR])
-> (VkWin32SurfaceCreateFlagsKHR
    -> VkWin32SurfaceCreateFlagsKHR
    -> VkWin32SurfaceCreateFlagsKHR
    -> [VkWin32SurfaceCreateFlagsKHR])
-> Enum VkWin32SurfaceCreateFlagsKHR
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: VkWin32SurfaceCreateFlagsKHR
-> VkWin32SurfaceCreateFlagsKHR
-> VkWin32SurfaceCreateFlagsKHR
-> [VkWin32SurfaceCreateFlagsKHR]
$cenumFromThenTo :: VkWin32SurfaceCreateFlagsKHR
-> VkWin32SurfaceCreateFlagsKHR
-> VkWin32SurfaceCreateFlagsKHR
-> [VkWin32SurfaceCreateFlagsKHR]
enumFromTo :: VkWin32SurfaceCreateFlagsKHR
-> VkWin32SurfaceCreateFlagsKHR -> [VkWin32SurfaceCreateFlagsKHR]
$cenumFromTo :: VkWin32SurfaceCreateFlagsKHR
-> VkWin32SurfaceCreateFlagsKHR -> [VkWin32SurfaceCreateFlagsKHR]
enumFromThen :: VkWin32SurfaceCreateFlagsKHR
-> VkWin32SurfaceCreateFlagsKHR -> [VkWin32SurfaceCreateFlagsKHR]
$cenumFromThen :: VkWin32SurfaceCreateFlagsKHR
-> VkWin32SurfaceCreateFlagsKHR -> [VkWin32SurfaceCreateFlagsKHR]
enumFrom :: VkWin32SurfaceCreateFlagsKHR -> [VkWin32SurfaceCreateFlagsKHR]
$cenumFrom :: VkWin32SurfaceCreateFlagsKHR -> [VkWin32SurfaceCreateFlagsKHR]
fromEnum :: VkWin32SurfaceCreateFlagsKHR -> Int
$cfromEnum :: VkWin32SurfaceCreateFlagsKHR -> Int
toEnum :: Int -> VkWin32SurfaceCreateFlagsKHR
$ctoEnum :: Int -> VkWin32SurfaceCreateFlagsKHR
pred :: VkWin32SurfaceCreateFlagsKHR -> VkWin32SurfaceCreateFlagsKHR
$cpred :: VkWin32SurfaceCreateFlagsKHR -> VkWin32SurfaceCreateFlagsKHR
succ :: VkWin32SurfaceCreateFlagsKHR -> VkWin32SurfaceCreateFlagsKHR
$csucc :: VkWin32SurfaceCreateFlagsKHR -> VkWin32SurfaceCreateFlagsKHR
Enum, Eq VkWin32SurfaceCreateFlagsKHR
VkWin32SurfaceCreateFlagsKHR
Eq VkWin32SurfaceCreateFlagsKHR
-> (VkWin32SurfaceCreateFlagsKHR
    -> VkWin32SurfaceCreateFlagsKHR -> VkWin32SurfaceCreateFlagsKHR)
-> (VkWin32SurfaceCreateFlagsKHR
    -> VkWin32SurfaceCreateFlagsKHR -> VkWin32SurfaceCreateFlagsKHR)
-> (VkWin32SurfaceCreateFlagsKHR
    -> VkWin32SurfaceCreateFlagsKHR -> VkWin32SurfaceCreateFlagsKHR)
-> (VkWin32SurfaceCreateFlagsKHR -> VkWin32SurfaceCreateFlagsKHR)
-> (VkWin32SurfaceCreateFlagsKHR
    -> Int -> VkWin32SurfaceCreateFlagsKHR)
-> (VkWin32SurfaceCreateFlagsKHR
    -> Int -> VkWin32SurfaceCreateFlagsKHR)
-> VkWin32SurfaceCreateFlagsKHR
-> (Int -> VkWin32SurfaceCreateFlagsKHR)
-> (VkWin32SurfaceCreateFlagsKHR
    -> Int -> VkWin32SurfaceCreateFlagsKHR)
-> (VkWin32SurfaceCreateFlagsKHR
    -> Int -> VkWin32SurfaceCreateFlagsKHR)
-> (VkWin32SurfaceCreateFlagsKHR
    -> Int -> VkWin32SurfaceCreateFlagsKHR)
-> (VkWin32SurfaceCreateFlagsKHR -> Int -> Bool)
-> (VkWin32SurfaceCreateFlagsKHR -> Maybe Int)
-> (VkWin32SurfaceCreateFlagsKHR -> Int)
-> (VkWin32SurfaceCreateFlagsKHR -> Bool)
-> (VkWin32SurfaceCreateFlagsKHR
    -> Int -> VkWin32SurfaceCreateFlagsKHR)
-> (VkWin32SurfaceCreateFlagsKHR
    -> Int -> VkWin32SurfaceCreateFlagsKHR)
-> (VkWin32SurfaceCreateFlagsKHR
    -> Int -> VkWin32SurfaceCreateFlagsKHR)
-> (VkWin32SurfaceCreateFlagsKHR
    -> Int -> VkWin32SurfaceCreateFlagsKHR)
-> (VkWin32SurfaceCreateFlagsKHR
    -> Int -> VkWin32SurfaceCreateFlagsKHR)
-> (VkWin32SurfaceCreateFlagsKHR
    -> Int -> VkWin32SurfaceCreateFlagsKHR)
-> (VkWin32SurfaceCreateFlagsKHR -> Int)
-> Bits VkWin32SurfaceCreateFlagsKHR
Int -> VkWin32SurfaceCreateFlagsKHR
VkWin32SurfaceCreateFlagsKHR -> Bool
VkWin32SurfaceCreateFlagsKHR -> Int
VkWin32SurfaceCreateFlagsKHR -> Maybe Int
VkWin32SurfaceCreateFlagsKHR -> VkWin32SurfaceCreateFlagsKHR
VkWin32SurfaceCreateFlagsKHR -> Int -> Bool
VkWin32SurfaceCreateFlagsKHR -> Int -> VkWin32SurfaceCreateFlagsKHR
VkWin32SurfaceCreateFlagsKHR
-> VkWin32SurfaceCreateFlagsKHR -> VkWin32SurfaceCreateFlagsKHR
forall a.
Eq a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
popCount :: VkWin32SurfaceCreateFlagsKHR -> Int
$cpopCount :: VkWin32SurfaceCreateFlagsKHR -> Int
rotateR :: VkWin32SurfaceCreateFlagsKHR -> Int -> VkWin32SurfaceCreateFlagsKHR
$crotateR :: VkWin32SurfaceCreateFlagsKHR -> Int -> VkWin32SurfaceCreateFlagsKHR
rotateL :: VkWin32SurfaceCreateFlagsKHR -> Int -> VkWin32SurfaceCreateFlagsKHR
$crotateL :: VkWin32SurfaceCreateFlagsKHR -> Int -> VkWin32SurfaceCreateFlagsKHR
unsafeShiftR :: VkWin32SurfaceCreateFlagsKHR -> Int -> VkWin32SurfaceCreateFlagsKHR
$cunsafeShiftR :: VkWin32SurfaceCreateFlagsKHR -> Int -> VkWin32SurfaceCreateFlagsKHR
shiftR :: VkWin32SurfaceCreateFlagsKHR -> Int -> VkWin32SurfaceCreateFlagsKHR
$cshiftR :: VkWin32SurfaceCreateFlagsKHR -> Int -> VkWin32SurfaceCreateFlagsKHR
unsafeShiftL :: VkWin32SurfaceCreateFlagsKHR -> Int -> VkWin32SurfaceCreateFlagsKHR
$cunsafeShiftL :: VkWin32SurfaceCreateFlagsKHR -> Int -> VkWin32SurfaceCreateFlagsKHR
shiftL :: VkWin32SurfaceCreateFlagsKHR -> Int -> VkWin32SurfaceCreateFlagsKHR
$cshiftL :: VkWin32SurfaceCreateFlagsKHR -> Int -> VkWin32SurfaceCreateFlagsKHR
isSigned :: VkWin32SurfaceCreateFlagsKHR -> Bool
$cisSigned :: VkWin32SurfaceCreateFlagsKHR -> Bool
bitSize :: VkWin32SurfaceCreateFlagsKHR -> Int
$cbitSize :: VkWin32SurfaceCreateFlagsKHR -> Int
bitSizeMaybe :: VkWin32SurfaceCreateFlagsKHR -> Maybe Int
$cbitSizeMaybe :: VkWin32SurfaceCreateFlagsKHR -> Maybe Int
testBit :: VkWin32SurfaceCreateFlagsKHR -> Int -> Bool
$ctestBit :: VkWin32SurfaceCreateFlagsKHR -> Int -> Bool
complementBit :: VkWin32SurfaceCreateFlagsKHR -> Int -> VkWin32SurfaceCreateFlagsKHR
$ccomplementBit :: VkWin32SurfaceCreateFlagsKHR -> Int -> VkWin32SurfaceCreateFlagsKHR
clearBit :: VkWin32SurfaceCreateFlagsKHR -> Int -> VkWin32SurfaceCreateFlagsKHR
$cclearBit :: VkWin32SurfaceCreateFlagsKHR -> Int -> VkWin32SurfaceCreateFlagsKHR
setBit :: VkWin32SurfaceCreateFlagsKHR -> Int -> VkWin32SurfaceCreateFlagsKHR
$csetBit :: VkWin32SurfaceCreateFlagsKHR -> Int -> VkWin32SurfaceCreateFlagsKHR
bit :: Int -> VkWin32SurfaceCreateFlagsKHR
$cbit :: Int -> VkWin32SurfaceCreateFlagsKHR
zeroBits :: VkWin32SurfaceCreateFlagsKHR
$czeroBits :: VkWin32SurfaceCreateFlagsKHR
rotate :: VkWin32SurfaceCreateFlagsKHR -> Int -> VkWin32SurfaceCreateFlagsKHR
$crotate :: VkWin32SurfaceCreateFlagsKHR -> Int -> VkWin32SurfaceCreateFlagsKHR
shift :: VkWin32SurfaceCreateFlagsKHR -> Int -> VkWin32SurfaceCreateFlagsKHR
$cshift :: VkWin32SurfaceCreateFlagsKHR -> Int -> VkWin32SurfaceCreateFlagsKHR
complement :: VkWin32SurfaceCreateFlagsKHR -> VkWin32SurfaceCreateFlagsKHR
$ccomplement :: VkWin32SurfaceCreateFlagsKHR -> VkWin32SurfaceCreateFlagsKHR
xor :: VkWin32SurfaceCreateFlagsKHR
-> VkWin32SurfaceCreateFlagsKHR -> VkWin32SurfaceCreateFlagsKHR
$cxor :: VkWin32SurfaceCreateFlagsKHR
-> VkWin32SurfaceCreateFlagsKHR -> VkWin32SurfaceCreateFlagsKHR
.|. :: VkWin32SurfaceCreateFlagsKHR
-> VkWin32SurfaceCreateFlagsKHR -> VkWin32SurfaceCreateFlagsKHR
$c.|. :: VkWin32SurfaceCreateFlagsKHR
-> VkWin32SurfaceCreateFlagsKHR -> VkWin32SurfaceCreateFlagsKHR
.&. :: VkWin32SurfaceCreateFlagsKHR
-> VkWin32SurfaceCreateFlagsKHR -> VkWin32SurfaceCreateFlagsKHR
$c.&. :: VkWin32SurfaceCreateFlagsKHR
-> VkWin32SurfaceCreateFlagsKHR -> VkWin32SurfaceCreateFlagsKHR
Bits, Bits VkWin32SurfaceCreateFlagsKHR
Bits VkWin32SurfaceCreateFlagsKHR
-> (VkWin32SurfaceCreateFlagsKHR -> Int)
-> (VkWin32SurfaceCreateFlagsKHR -> Int)
-> (VkWin32SurfaceCreateFlagsKHR -> Int)
-> FiniteBits VkWin32SurfaceCreateFlagsKHR
VkWin32SurfaceCreateFlagsKHR -> Int
forall b.
Bits b -> (b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
countTrailingZeros :: VkWin32SurfaceCreateFlagsKHR -> Int
$ccountTrailingZeros :: VkWin32SurfaceCreateFlagsKHR -> Int
countLeadingZeros :: VkWin32SurfaceCreateFlagsKHR -> Int
$ccountLeadingZeros :: VkWin32SurfaceCreateFlagsKHR -> Int
finiteBitSize :: VkWin32SurfaceCreateFlagsKHR -> Int
$cfiniteBitSize :: VkWin32SurfaceCreateFlagsKHR -> Int
FiniteBits, Ptr VkWin32SurfaceCreateFlagsKHR -> IO VkWin32SurfaceCreateFlagsKHR
Ptr VkWin32SurfaceCreateFlagsKHR
-> Int -> IO VkWin32SurfaceCreateFlagsKHR
Ptr VkWin32SurfaceCreateFlagsKHR
-> Int -> VkWin32SurfaceCreateFlagsKHR -> IO ()
Ptr VkWin32SurfaceCreateFlagsKHR
-> VkWin32SurfaceCreateFlagsKHR -> IO ()
VkWin32SurfaceCreateFlagsKHR -> Int
(VkWin32SurfaceCreateFlagsKHR -> Int)
-> (VkWin32SurfaceCreateFlagsKHR -> Int)
-> (Ptr VkWin32SurfaceCreateFlagsKHR
    -> Int -> IO VkWin32SurfaceCreateFlagsKHR)
-> (Ptr VkWin32SurfaceCreateFlagsKHR
    -> Int -> VkWin32SurfaceCreateFlagsKHR -> IO ())
-> (forall b. Ptr b -> Int -> IO VkWin32SurfaceCreateFlagsKHR)
-> (forall b.
    Ptr b -> Int -> VkWin32SurfaceCreateFlagsKHR -> IO ())
-> (Ptr VkWin32SurfaceCreateFlagsKHR
    -> IO VkWin32SurfaceCreateFlagsKHR)
-> (Ptr VkWin32SurfaceCreateFlagsKHR
    -> VkWin32SurfaceCreateFlagsKHR -> IO ())
-> Storable VkWin32SurfaceCreateFlagsKHR
forall b. Ptr b -> Int -> IO VkWin32SurfaceCreateFlagsKHR
forall b. Ptr b -> Int -> VkWin32SurfaceCreateFlagsKHR -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr VkWin32SurfaceCreateFlagsKHR
-> VkWin32SurfaceCreateFlagsKHR -> IO ()
$cpoke :: Ptr VkWin32SurfaceCreateFlagsKHR
-> VkWin32SurfaceCreateFlagsKHR -> IO ()
peek :: Ptr VkWin32SurfaceCreateFlagsKHR -> IO VkWin32SurfaceCreateFlagsKHR
$cpeek :: Ptr VkWin32SurfaceCreateFlagsKHR -> IO VkWin32SurfaceCreateFlagsKHR
pokeByteOff :: forall b. Ptr b -> Int -> VkWin32SurfaceCreateFlagsKHR -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> VkWin32SurfaceCreateFlagsKHR -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO VkWin32SurfaceCreateFlagsKHR
$cpeekByteOff :: forall b. Ptr b -> Int -> IO VkWin32SurfaceCreateFlagsKHR
pokeElemOff :: Ptr VkWin32SurfaceCreateFlagsKHR
-> Int -> VkWin32SurfaceCreateFlagsKHR -> IO ()
$cpokeElemOff :: Ptr VkWin32SurfaceCreateFlagsKHR
-> Int -> VkWin32SurfaceCreateFlagsKHR -> IO ()
peekElemOff :: Ptr VkWin32SurfaceCreateFlagsKHR
-> Int -> IO VkWin32SurfaceCreateFlagsKHR
$cpeekElemOff :: Ptr VkWin32SurfaceCreateFlagsKHR
-> Int -> IO VkWin32SurfaceCreateFlagsKHR
alignment :: VkWin32SurfaceCreateFlagsKHR -> Int
$calignment :: VkWin32SurfaceCreateFlagsKHR -> Int
sizeOf :: VkWin32SurfaceCreateFlagsKHR -> Int
$csizeOf :: VkWin32SurfaceCreateFlagsKHR -> Int
Storable)

instance Show VkWin32SurfaceCreateFlagsKHR where
    {-# INLINE showsPrec #-}
    showsPrec :: Int -> VkWin32SurfaceCreateFlagsKHR -> ShowS
showsPrec = (Int -> VkFlags -> ShowS)
-> Int -> VkWin32SurfaceCreateFlagsKHR -> ShowS
coerce (Int -> VkFlags -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec :: Int -> VkFlags -> ShowS)

instance Read VkWin32SurfaceCreateFlagsKHR where
    {-# INLINE readsPrec #-}
    readsPrec :: Int -> ReadS VkWin32SurfaceCreateFlagsKHR
readsPrec = (Int -> ReadS VkFlags) -> Int -> ReadS VkWin32SurfaceCreateFlagsKHR
coerce (Int -> ReadS VkFlags
forall a. Read a => Int -> ReadS a
readsPrec :: Int -> ReadS VkFlags)

newtype VkXcbSurfaceCreateFlagsKHR = VkXcbSurfaceCreateFlagsKHR VkFlags
                                     deriving (VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR -> Bool
(VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR -> Bool)
-> (VkXcbSurfaceCreateFlagsKHR
    -> VkXcbSurfaceCreateFlagsKHR -> Bool)
-> Eq VkXcbSurfaceCreateFlagsKHR
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR -> Bool
$c/= :: VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR -> Bool
== :: VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR -> Bool
$c== :: VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR -> Bool
Eq, Eq VkXcbSurfaceCreateFlagsKHR
Eq VkXcbSurfaceCreateFlagsKHR
-> (VkXcbSurfaceCreateFlagsKHR
    -> VkXcbSurfaceCreateFlagsKHR -> Ordering)
-> (VkXcbSurfaceCreateFlagsKHR
    -> VkXcbSurfaceCreateFlagsKHR -> Bool)
-> (VkXcbSurfaceCreateFlagsKHR
    -> VkXcbSurfaceCreateFlagsKHR -> Bool)
-> (VkXcbSurfaceCreateFlagsKHR
    -> VkXcbSurfaceCreateFlagsKHR -> Bool)
-> (VkXcbSurfaceCreateFlagsKHR
    -> VkXcbSurfaceCreateFlagsKHR -> Bool)
-> (VkXcbSurfaceCreateFlagsKHR
    -> VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR)
-> (VkXcbSurfaceCreateFlagsKHR
    -> VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR)
-> Ord VkXcbSurfaceCreateFlagsKHR
VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR -> Bool
VkXcbSurfaceCreateFlagsKHR
-> VkXcbSurfaceCreateFlagsKHR -> Ordering
VkXcbSurfaceCreateFlagsKHR
-> VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: VkXcbSurfaceCreateFlagsKHR
-> VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR
$cmin :: VkXcbSurfaceCreateFlagsKHR
-> VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR
max :: VkXcbSurfaceCreateFlagsKHR
-> VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR
$cmax :: VkXcbSurfaceCreateFlagsKHR
-> VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR
>= :: VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR -> Bool
$c>= :: VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR -> Bool
> :: VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR -> Bool
$c> :: VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR -> Bool
<= :: VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR -> Bool
$c<= :: VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR -> Bool
< :: VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR -> Bool
$c< :: VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR -> Bool
compare :: VkXcbSurfaceCreateFlagsKHR
-> VkXcbSurfaceCreateFlagsKHR -> Ordering
$ccompare :: VkXcbSurfaceCreateFlagsKHR
-> VkXcbSurfaceCreateFlagsKHR -> Ordering
Ord, Int -> VkXcbSurfaceCreateFlagsKHR
VkXcbSurfaceCreateFlagsKHR -> Int
VkXcbSurfaceCreateFlagsKHR -> [VkXcbSurfaceCreateFlagsKHR]
VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR
VkXcbSurfaceCreateFlagsKHR
-> VkXcbSurfaceCreateFlagsKHR -> [VkXcbSurfaceCreateFlagsKHR]
VkXcbSurfaceCreateFlagsKHR
-> VkXcbSurfaceCreateFlagsKHR
-> VkXcbSurfaceCreateFlagsKHR
-> [VkXcbSurfaceCreateFlagsKHR]
(VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR)
-> (VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR)
-> (Int -> VkXcbSurfaceCreateFlagsKHR)
-> (VkXcbSurfaceCreateFlagsKHR -> Int)
-> (VkXcbSurfaceCreateFlagsKHR -> [VkXcbSurfaceCreateFlagsKHR])
-> (VkXcbSurfaceCreateFlagsKHR
    -> VkXcbSurfaceCreateFlagsKHR -> [VkXcbSurfaceCreateFlagsKHR])
-> (VkXcbSurfaceCreateFlagsKHR
    -> VkXcbSurfaceCreateFlagsKHR -> [VkXcbSurfaceCreateFlagsKHR])
-> (VkXcbSurfaceCreateFlagsKHR
    -> VkXcbSurfaceCreateFlagsKHR
    -> VkXcbSurfaceCreateFlagsKHR
    -> [VkXcbSurfaceCreateFlagsKHR])
-> Enum VkXcbSurfaceCreateFlagsKHR
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: VkXcbSurfaceCreateFlagsKHR
-> VkXcbSurfaceCreateFlagsKHR
-> VkXcbSurfaceCreateFlagsKHR
-> [VkXcbSurfaceCreateFlagsKHR]
$cenumFromThenTo :: VkXcbSurfaceCreateFlagsKHR
-> VkXcbSurfaceCreateFlagsKHR
-> VkXcbSurfaceCreateFlagsKHR
-> [VkXcbSurfaceCreateFlagsKHR]
enumFromTo :: VkXcbSurfaceCreateFlagsKHR
-> VkXcbSurfaceCreateFlagsKHR -> [VkXcbSurfaceCreateFlagsKHR]
$cenumFromTo :: VkXcbSurfaceCreateFlagsKHR
-> VkXcbSurfaceCreateFlagsKHR -> [VkXcbSurfaceCreateFlagsKHR]
enumFromThen :: VkXcbSurfaceCreateFlagsKHR
-> VkXcbSurfaceCreateFlagsKHR -> [VkXcbSurfaceCreateFlagsKHR]
$cenumFromThen :: VkXcbSurfaceCreateFlagsKHR
-> VkXcbSurfaceCreateFlagsKHR -> [VkXcbSurfaceCreateFlagsKHR]
enumFrom :: VkXcbSurfaceCreateFlagsKHR -> [VkXcbSurfaceCreateFlagsKHR]
$cenumFrom :: VkXcbSurfaceCreateFlagsKHR -> [VkXcbSurfaceCreateFlagsKHR]
fromEnum :: VkXcbSurfaceCreateFlagsKHR -> Int
$cfromEnum :: VkXcbSurfaceCreateFlagsKHR -> Int
toEnum :: Int -> VkXcbSurfaceCreateFlagsKHR
$ctoEnum :: Int -> VkXcbSurfaceCreateFlagsKHR
pred :: VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR
$cpred :: VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR
succ :: VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR
$csucc :: VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR
Enum, Eq VkXcbSurfaceCreateFlagsKHR
VkXcbSurfaceCreateFlagsKHR
Eq VkXcbSurfaceCreateFlagsKHR
-> (VkXcbSurfaceCreateFlagsKHR
    -> VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR)
-> (VkXcbSurfaceCreateFlagsKHR
    -> VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR)
-> (VkXcbSurfaceCreateFlagsKHR
    -> VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR)
-> (VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR)
-> (VkXcbSurfaceCreateFlagsKHR
    -> Int -> VkXcbSurfaceCreateFlagsKHR)
-> (VkXcbSurfaceCreateFlagsKHR
    -> Int -> VkXcbSurfaceCreateFlagsKHR)
-> VkXcbSurfaceCreateFlagsKHR
-> (Int -> VkXcbSurfaceCreateFlagsKHR)
-> (VkXcbSurfaceCreateFlagsKHR
    -> Int -> VkXcbSurfaceCreateFlagsKHR)
-> (VkXcbSurfaceCreateFlagsKHR
    -> Int -> VkXcbSurfaceCreateFlagsKHR)
-> (VkXcbSurfaceCreateFlagsKHR
    -> Int -> VkXcbSurfaceCreateFlagsKHR)
-> (VkXcbSurfaceCreateFlagsKHR -> Int -> Bool)
-> (VkXcbSurfaceCreateFlagsKHR -> Maybe Int)
-> (VkXcbSurfaceCreateFlagsKHR -> Int)
-> (VkXcbSurfaceCreateFlagsKHR -> Bool)
-> (VkXcbSurfaceCreateFlagsKHR
    -> Int -> VkXcbSurfaceCreateFlagsKHR)
-> (VkXcbSurfaceCreateFlagsKHR
    -> Int -> VkXcbSurfaceCreateFlagsKHR)
-> (VkXcbSurfaceCreateFlagsKHR
    -> Int -> VkXcbSurfaceCreateFlagsKHR)
-> (VkXcbSurfaceCreateFlagsKHR
    -> Int -> VkXcbSurfaceCreateFlagsKHR)
-> (VkXcbSurfaceCreateFlagsKHR
    -> Int -> VkXcbSurfaceCreateFlagsKHR)
-> (VkXcbSurfaceCreateFlagsKHR
    -> Int -> VkXcbSurfaceCreateFlagsKHR)
-> (VkXcbSurfaceCreateFlagsKHR -> Int)
-> Bits VkXcbSurfaceCreateFlagsKHR
Int -> VkXcbSurfaceCreateFlagsKHR
VkXcbSurfaceCreateFlagsKHR -> Bool
VkXcbSurfaceCreateFlagsKHR -> Int
VkXcbSurfaceCreateFlagsKHR -> Maybe Int
VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR
VkXcbSurfaceCreateFlagsKHR -> Int -> Bool
VkXcbSurfaceCreateFlagsKHR -> Int -> VkXcbSurfaceCreateFlagsKHR
VkXcbSurfaceCreateFlagsKHR
-> VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR
forall a.
Eq a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
popCount :: VkXcbSurfaceCreateFlagsKHR -> Int
$cpopCount :: VkXcbSurfaceCreateFlagsKHR -> Int
rotateR :: VkXcbSurfaceCreateFlagsKHR -> Int -> VkXcbSurfaceCreateFlagsKHR
$crotateR :: VkXcbSurfaceCreateFlagsKHR -> Int -> VkXcbSurfaceCreateFlagsKHR
rotateL :: VkXcbSurfaceCreateFlagsKHR -> Int -> VkXcbSurfaceCreateFlagsKHR
$crotateL :: VkXcbSurfaceCreateFlagsKHR -> Int -> VkXcbSurfaceCreateFlagsKHR
unsafeShiftR :: VkXcbSurfaceCreateFlagsKHR -> Int -> VkXcbSurfaceCreateFlagsKHR
$cunsafeShiftR :: VkXcbSurfaceCreateFlagsKHR -> Int -> VkXcbSurfaceCreateFlagsKHR
shiftR :: VkXcbSurfaceCreateFlagsKHR -> Int -> VkXcbSurfaceCreateFlagsKHR
$cshiftR :: VkXcbSurfaceCreateFlagsKHR -> Int -> VkXcbSurfaceCreateFlagsKHR
unsafeShiftL :: VkXcbSurfaceCreateFlagsKHR -> Int -> VkXcbSurfaceCreateFlagsKHR
$cunsafeShiftL :: VkXcbSurfaceCreateFlagsKHR -> Int -> VkXcbSurfaceCreateFlagsKHR
shiftL :: VkXcbSurfaceCreateFlagsKHR -> Int -> VkXcbSurfaceCreateFlagsKHR
$cshiftL :: VkXcbSurfaceCreateFlagsKHR -> Int -> VkXcbSurfaceCreateFlagsKHR
isSigned :: VkXcbSurfaceCreateFlagsKHR -> Bool
$cisSigned :: VkXcbSurfaceCreateFlagsKHR -> Bool
bitSize :: VkXcbSurfaceCreateFlagsKHR -> Int
$cbitSize :: VkXcbSurfaceCreateFlagsKHR -> Int
bitSizeMaybe :: VkXcbSurfaceCreateFlagsKHR -> Maybe Int
$cbitSizeMaybe :: VkXcbSurfaceCreateFlagsKHR -> Maybe Int
testBit :: VkXcbSurfaceCreateFlagsKHR -> Int -> Bool
$ctestBit :: VkXcbSurfaceCreateFlagsKHR -> Int -> Bool
complementBit :: VkXcbSurfaceCreateFlagsKHR -> Int -> VkXcbSurfaceCreateFlagsKHR
$ccomplementBit :: VkXcbSurfaceCreateFlagsKHR -> Int -> VkXcbSurfaceCreateFlagsKHR
clearBit :: VkXcbSurfaceCreateFlagsKHR -> Int -> VkXcbSurfaceCreateFlagsKHR
$cclearBit :: VkXcbSurfaceCreateFlagsKHR -> Int -> VkXcbSurfaceCreateFlagsKHR
setBit :: VkXcbSurfaceCreateFlagsKHR -> Int -> VkXcbSurfaceCreateFlagsKHR
$csetBit :: VkXcbSurfaceCreateFlagsKHR -> Int -> VkXcbSurfaceCreateFlagsKHR
bit :: Int -> VkXcbSurfaceCreateFlagsKHR
$cbit :: Int -> VkXcbSurfaceCreateFlagsKHR
zeroBits :: VkXcbSurfaceCreateFlagsKHR
$czeroBits :: VkXcbSurfaceCreateFlagsKHR
rotate :: VkXcbSurfaceCreateFlagsKHR -> Int -> VkXcbSurfaceCreateFlagsKHR
$crotate :: VkXcbSurfaceCreateFlagsKHR -> Int -> VkXcbSurfaceCreateFlagsKHR
shift :: VkXcbSurfaceCreateFlagsKHR -> Int -> VkXcbSurfaceCreateFlagsKHR
$cshift :: VkXcbSurfaceCreateFlagsKHR -> Int -> VkXcbSurfaceCreateFlagsKHR
complement :: VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR
$ccomplement :: VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR
xor :: VkXcbSurfaceCreateFlagsKHR
-> VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR
$cxor :: VkXcbSurfaceCreateFlagsKHR
-> VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR
.|. :: VkXcbSurfaceCreateFlagsKHR
-> VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR
$c.|. :: VkXcbSurfaceCreateFlagsKHR
-> VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR
.&. :: VkXcbSurfaceCreateFlagsKHR
-> VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR
$c.&. :: VkXcbSurfaceCreateFlagsKHR
-> VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR
Bits, Bits VkXcbSurfaceCreateFlagsKHR
Bits VkXcbSurfaceCreateFlagsKHR
-> (VkXcbSurfaceCreateFlagsKHR -> Int)
-> (VkXcbSurfaceCreateFlagsKHR -> Int)
-> (VkXcbSurfaceCreateFlagsKHR -> Int)
-> FiniteBits VkXcbSurfaceCreateFlagsKHR
VkXcbSurfaceCreateFlagsKHR -> Int
forall b.
Bits b -> (b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
countTrailingZeros :: VkXcbSurfaceCreateFlagsKHR -> Int
$ccountTrailingZeros :: VkXcbSurfaceCreateFlagsKHR -> Int
countLeadingZeros :: VkXcbSurfaceCreateFlagsKHR -> Int
$ccountLeadingZeros :: VkXcbSurfaceCreateFlagsKHR -> Int
finiteBitSize :: VkXcbSurfaceCreateFlagsKHR -> Int
$cfiniteBitSize :: VkXcbSurfaceCreateFlagsKHR -> Int
FiniteBits, Ptr VkXcbSurfaceCreateFlagsKHR -> IO VkXcbSurfaceCreateFlagsKHR
Ptr VkXcbSurfaceCreateFlagsKHR
-> Int -> IO VkXcbSurfaceCreateFlagsKHR
Ptr VkXcbSurfaceCreateFlagsKHR
-> Int -> VkXcbSurfaceCreateFlagsKHR -> IO ()
Ptr VkXcbSurfaceCreateFlagsKHR
-> VkXcbSurfaceCreateFlagsKHR -> IO ()
VkXcbSurfaceCreateFlagsKHR -> Int
(VkXcbSurfaceCreateFlagsKHR -> Int)
-> (VkXcbSurfaceCreateFlagsKHR -> Int)
-> (Ptr VkXcbSurfaceCreateFlagsKHR
    -> Int -> IO VkXcbSurfaceCreateFlagsKHR)
-> (Ptr VkXcbSurfaceCreateFlagsKHR
    -> Int -> VkXcbSurfaceCreateFlagsKHR -> IO ())
-> (forall b. Ptr b -> Int -> IO VkXcbSurfaceCreateFlagsKHR)
-> (forall b. Ptr b -> Int -> VkXcbSurfaceCreateFlagsKHR -> IO ())
-> (Ptr VkXcbSurfaceCreateFlagsKHR
    -> IO VkXcbSurfaceCreateFlagsKHR)
-> (Ptr VkXcbSurfaceCreateFlagsKHR
    -> VkXcbSurfaceCreateFlagsKHR -> IO ())
-> Storable VkXcbSurfaceCreateFlagsKHR
forall b. Ptr b -> Int -> IO VkXcbSurfaceCreateFlagsKHR
forall b. Ptr b -> Int -> VkXcbSurfaceCreateFlagsKHR -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr VkXcbSurfaceCreateFlagsKHR
-> VkXcbSurfaceCreateFlagsKHR -> IO ()
$cpoke :: Ptr VkXcbSurfaceCreateFlagsKHR
-> VkXcbSurfaceCreateFlagsKHR -> IO ()
peek :: Ptr VkXcbSurfaceCreateFlagsKHR -> IO VkXcbSurfaceCreateFlagsKHR
$cpeek :: Ptr VkXcbSurfaceCreateFlagsKHR -> IO VkXcbSurfaceCreateFlagsKHR
pokeByteOff :: forall b. Ptr b -> Int -> VkXcbSurfaceCreateFlagsKHR -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> VkXcbSurfaceCreateFlagsKHR -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO VkXcbSurfaceCreateFlagsKHR
$cpeekByteOff :: forall b. Ptr b -> Int -> IO VkXcbSurfaceCreateFlagsKHR
pokeElemOff :: Ptr VkXcbSurfaceCreateFlagsKHR
-> Int -> VkXcbSurfaceCreateFlagsKHR -> IO ()
$cpokeElemOff :: Ptr VkXcbSurfaceCreateFlagsKHR
-> Int -> VkXcbSurfaceCreateFlagsKHR -> IO ()
peekElemOff :: Ptr VkXcbSurfaceCreateFlagsKHR
-> Int -> IO VkXcbSurfaceCreateFlagsKHR
$cpeekElemOff :: Ptr VkXcbSurfaceCreateFlagsKHR
-> Int -> IO VkXcbSurfaceCreateFlagsKHR
alignment :: VkXcbSurfaceCreateFlagsKHR -> Int
$calignment :: VkXcbSurfaceCreateFlagsKHR -> Int
sizeOf :: VkXcbSurfaceCreateFlagsKHR -> Int
$csizeOf :: VkXcbSurfaceCreateFlagsKHR -> Int
Storable)

instance Show VkXcbSurfaceCreateFlagsKHR where
    {-# INLINE showsPrec #-}
    showsPrec :: Int -> VkXcbSurfaceCreateFlagsKHR -> ShowS
showsPrec = (Int -> VkFlags -> ShowS)
-> Int -> VkXcbSurfaceCreateFlagsKHR -> ShowS
coerce (Int -> VkFlags -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec :: Int -> VkFlags -> ShowS)

instance Read VkXcbSurfaceCreateFlagsKHR where
    {-# INLINE readsPrec #-}
    readsPrec :: Int -> ReadS VkXcbSurfaceCreateFlagsKHR
readsPrec = (Int -> ReadS VkFlags) -> Int -> ReadS VkXcbSurfaceCreateFlagsKHR
coerce (Int -> ReadS VkFlags
forall a. Read a => Int -> ReadS a
readsPrec :: Int -> ReadS VkFlags)

newtype VkXlibSurfaceCreateFlagsKHR = VkXlibSurfaceCreateFlagsKHR VkFlags
                                      deriving (VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR -> Bool
(VkXlibSurfaceCreateFlagsKHR
 -> VkXlibSurfaceCreateFlagsKHR -> Bool)
-> (VkXlibSurfaceCreateFlagsKHR
    -> VkXlibSurfaceCreateFlagsKHR -> Bool)
-> Eq VkXlibSurfaceCreateFlagsKHR
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR -> Bool
$c/= :: VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR -> Bool
== :: VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR -> Bool
$c== :: VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR -> Bool
Eq, Eq VkXlibSurfaceCreateFlagsKHR
Eq VkXlibSurfaceCreateFlagsKHR
-> (VkXlibSurfaceCreateFlagsKHR
    -> VkXlibSurfaceCreateFlagsKHR -> Ordering)
-> (VkXlibSurfaceCreateFlagsKHR
    -> VkXlibSurfaceCreateFlagsKHR -> Bool)
-> (VkXlibSurfaceCreateFlagsKHR
    -> VkXlibSurfaceCreateFlagsKHR -> Bool)
-> (VkXlibSurfaceCreateFlagsKHR
    -> VkXlibSurfaceCreateFlagsKHR -> Bool)
-> (VkXlibSurfaceCreateFlagsKHR
    -> VkXlibSurfaceCreateFlagsKHR -> Bool)
-> (VkXlibSurfaceCreateFlagsKHR
    -> VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR)
-> (VkXlibSurfaceCreateFlagsKHR
    -> VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR)
-> Ord VkXlibSurfaceCreateFlagsKHR
VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR -> Bool
VkXlibSurfaceCreateFlagsKHR
-> VkXlibSurfaceCreateFlagsKHR -> Ordering
VkXlibSurfaceCreateFlagsKHR
-> VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: VkXlibSurfaceCreateFlagsKHR
-> VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR
$cmin :: VkXlibSurfaceCreateFlagsKHR
-> VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR
max :: VkXlibSurfaceCreateFlagsKHR
-> VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR
$cmax :: VkXlibSurfaceCreateFlagsKHR
-> VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR
>= :: VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR -> Bool
$c>= :: VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR -> Bool
> :: VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR -> Bool
$c> :: VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR -> Bool
<= :: VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR -> Bool
$c<= :: VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR -> Bool
< :: VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR -> Bool
$c< :: VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR -> Bool
compare :: VkXlibSurfaceCreateFlagsKHR
-> VkXlibSurfaceCreateFlagsKHR -> Ordering
$ccompare :: VkXlibSurfaceCreateFlagsKHR
-> VkXlibSurfaceCreateFlagsKHR -> Ordering
Ord, Int -> VkXlibSurfaceCreateFlagsKHR
VkXlibSurfaceCreateFlagsKHR -> Int
VkXlibSurfaceCreateFlagsKHR -> [VkXlibSurfaceCreateFlagsKHR]
VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR
VkXlibSurfaceCreateFlagsKHR
-> VkXlibSurfaceCreateFlagsKHR -> [VkXlibSurfaceCreateFlagsKHR]
VkXlibSurfaceCreateFlagsKHR
-> VkXlibSurfaceCreateFlagsKHR
-> VkXlibSurfaceCreateFlagsKHR
-> [VkXlibSurfaceCreateFlagsKHR]
(VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR)
-> (VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR)
-> (Int -> VkXlibSurfaceCreateFlagsKHR)
-> (VkXlibSurfaceCreateFlagsKHR -> Int)
-> (VkXlibSurfaceCreateFlagsKHR -> [VkXlibSurfaceCreateFlagsKHR])
-> (VkXlibSurfaceCreateFlagsKHR
    -> VkXlibSurfaceCreateFlagsKHR -> [VkXlibSurfaceCreateFlagsKHR])
-> (VkXlibSurfaceCreateFlagsKHR
    -> VkXlibSurfaceCreateFlagsKHR -> [VkXlibSurfaceCreateFlagsKHR])
-> (VkXlibSurfaceCreateFlagsKHR
    -> VkXlibSurfaceCreateFlagsKHR
    -> VkXlibSurfaceCreateFlagsKHR
    -> [VkXlibSurfaceCreateFlagsKHR])
-> Enum VkXlibSurfaceCreateFlagsKHR
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: VkXlibSurfaceCreateFlagsKHR
-> VkXlibSurfaceCreateFlagsKHR
-> VkXlibSurfaceCreateFlagsKHR
-> [VkXlibSurfaceCreateFlagsKHR]
$cenumFromThenTo :: VkXlibSurfaceCreateFlagsKHR
-> VkXlibSurfaceCreateFlagsKHR
-> VkXlibSurfaceCreateFlagsKHR
-> [VkXlibSurfaceCreateFlagsKHR]
enumFromTo :: VkXlibSurfaceCreateFlagsKHR
-> VkXlibSurfaceCreateFlagsKHR -> [VkXlibSurfaceCreateFlagsKHR]
$cenumFromTo :: VkXlibSurfaceCreateFlagsKHR
-> VkXlibSurfaceCreateFlagsKHR -> [VkXlibSurfaceCreateFlagsKHR]
enumFromThen :: VkXlibSurfaceCreateFlagsKHR
-> VkXlibSurfaceCreateFlagsKHR -> [VkXlibSurfaceCreateFlagsKHR]
$cenumFromThen :: VkXlibSurfaceCreateFlagsKHR
-> VkXlibSurfaceCreateFlagsKHR -> [VkXlibSurfaceCreateFlagsKHR]
enumFrom :: VkXlibSurfaceCreateFlagsKHR -> [VkXlibSurfaceCreateFlagsKHR]
$cenumFrom :: VkXlibSurfaceCreateFlagsKHR -> [VkXlibSurfaceCreateFlagsKHR]
fromEnum :: VkXlibSurfaceCreateFlagsKHR -> Int
$cfromEnum :: VkXlibSurfaceCreateFlagsKHR -> Int
toEnum :: Int -> VkXlibSurfaceCreateFlagsKHR
$ctoEnum :: Int -> VkXlibSurfaceCreateFlagsKHR
pred :: VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR
$cpred :: VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR
succ :: VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR
$csucc :: VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR
Enum, Eq VkXlibSurfaceCreateFlagsKHR
VkXlibSurfaceCreateFlagsKHR
Eq VkXlibSurfaceCreateFlagsKHR
-> (VkXlibSurfaceCreateFlagsKHR
    -> VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR)
-> (VkXlibSurfaceCreateFlagsKHR
    -> VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR)
-> (VkXlibSurfaceCreateFlagsKHR
    -> VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR)
-> (VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR)
-> (VkXlibSurfaceCreateFlagsKHR
    -> Int -> VkXlibSurfaceCreateFlagsKHR)
-> (VkXlibSurfaceCreateFlagsKHR
    -> Int -> VkXlibSurfaceCreateFlagsKHR)
-> VkXlibSurfaceCreateFlagsKHR
-> (Int -> VkXlibSurfaceCreateFlagsKHR)
-> (VkXlibSurfaceCreateFlagsKHR
    -> Int -> VkXlibSurfaceCreateFlagsKHR)
-> (VkXlibSurfaceCreateFlagsKHR
    -> Int -> VkXlibSurfaceCreateFlagsKHR)
-> (VkXlibSurfaceCreateFlagsKHR
    -> Int -> VkXlibSurfaceCreateFlagsKHR)
-> (VkXlibSurfaceCreateFlagsKHR -> Int -> Bool)
-> (VkXlibSurfaceCreateFlagsKHR -> Maybe Int)
-> (VkXlibSurfaceCreateFlagsKHR -> Int)
-> (VkXlibSurfaceCreateFlagsKHR -> Bool)
-> (VkXlibSurfaceCreateFlagsKHR
    -> Int -> VkXlibSurfaceCreateFlagsKHR)
-> (VkXlibSurfaceCreateFlagsKHR
    -> Int -> VkXlibSurfaceCreateFlagsKHR)
-> (VkXlibSurfaceCreateFlagsKHR
    -> Int -> VkXlibSurfaceCreateFlagsKHR)
-> (VkXlibSurfaceCreateFlagsKHR
    -> Int -> VkXlibSurfaceCreateFlagsKHR)
-> (VkXlibSurfaceCreateFlagsKHR
    -> Int -> VkXlibSurfaceCreateFlagsKHR)
-> (VkXlibSurfaceCreateFlagsKHR
    -> Int -> VkXlibSurfaceCreateFlagsKHR)
-> (VkXlibSurfaceCreateFlagsKHR -> Int)
-> Bits VkXlibSurfaceCreateFlagsKHR
Int -> VkXlibSurfaceCreateFlagsKHR
VkXlibSurfaceCreateFlagsKHR -> Bool
VkXlibSurfaceCreateFlagsKHR -> Int
VkXlibSurfaceCreateFlagsKHR -> Maybe Int
VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR
VkXlibSurfaceCreateFlagsKHR -> Int -> Bool
VkXlibSurfaceCreateFlagsKHR -> Int -> VkXlibSurfaceCreateFlagsKHR
VkXlibSurfaceCreateFlagsKHR
-> VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR
forall a.
Eq a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
popCount :: VkXlibSurfaceCreateFlagsKHR -> Int
$cpopCount :: VkXlibSurfaceCreateFlagsKHR -> Int
rotateR :: VkXlibSurfaceCreateFlagsKHR -> Int -> VkXlibSurfaceCreateFlagsKHR
$crotateR :: VkXlibSurfaceCreateFlagsKHR -> Int -> VkXlibSurfaceCreateFlagsKHR
rotateL :: VkXlibSurfaceCreateFlagsKHR -> Int -> VkXlibSurfaceCreateFlagsKHR
$crotateL :: VkXlibSurfaceCreateFlagsKHR -> Int -> VkXlibSurfaceCreateFlagsKHR
unsafeShiftR :: VkXlibSurfaceCreateFlagsKHR -> Int -> VkXlibSurfaceCreateFlagsKHR
$cunsafeShiftR :: VkXlibSurfaceCreateFlagsKHR -> Int -> VkXlibSurfaceCreateFlagsKHR
shiftR :: VkXlibSurfaceCreateFlagsKHR -> Int -> VkXlibSurfaceCreateFlagsKHR
$cshiftR :: VkXlibSurfaceCreateFlagsKHR -> Int -> VkXlibSurfaceCreateFlagsKHR
unsafeShiftL :: VkXlibSurfaceCreateFlagsKHR -> Int -> VkXlibSurfaceCreateFlagsKHR
$cunsafeShiftL :: VkXlibSurfaceCreateFlagsKHR -> Int -> VkXlibSurfaceCreateFlagsKHR
shiftL :: VkXlibSurfaceCreateFlagsKHR -> Int -> VkXlibSurfaceCreateFlagsKHR
$cshiftL :: VkXlibSurfaceCreateFlagsKHR -> Int -> VkXlibSurfaceCreateFlagsKHR
isSigned :: VkXlibSurfaceCreateFlagsKHR -> Bool
$cisSigned :: VkXlibSurfaceCreateFlagsKHR -> Bool
bitSize :: VkXlibSurfaceCreateFlagsKHR -> Int
$cbitSize :: VkXlibSurfaceCreateFlagsKHR -> Int
bitSizeMaybe :: VkXlibSurfaceCreateFlagsKHR -> Maybe Int
$cbitSizeMaybe :: VkXlibSurfaceCreateFlagsKHR -> Maybe Int
testBit :: VkXlibSurfaceCreateFlagsKHR -> Int -> Bool
$ctestBit :: VkXlibSurfaceCreateFlagsKHR -> Int -> Bool
complementBit :: VkXlibSurfaceCreateFlagsKHR -> Int -> VkXlibSurfaceCreateFlagsKHR
$ccomplementBit :: VkXlibSurfaceCreateFlagsKHR -> Int -> VkXlibSurfaceCreateFlagsKHR
clearBit :: VkXlibSurfaceCreateFlagsKHR -> Int -> VkXlibSurfaceCreateFlagsKHR
$cclearBit :: VkXlibSurfaceCreateFlagsKHR -> Int -> VkXlibSurfaceCreateFlagsKHR
setBit :: VkXlibSurfaceCreateFlagsKHR -> Int -> VkXlibSurfaceCreateFlagsKHR
$csetBit :: VkXlibSurfaceCreateFlagsKHR -> Int -> VkXlibSurfaceCreateFlagsKHR
bit :: Int -> VkXlibSurfaceCreateFlagsKHR
$cbit :: Int -> VkXlibSurfaceCreateFlagsKHR
zeroBits :: VkXlibSurfaceCreateFlagsKHR
$czeroBits :: VkXlibSurfaceCreateFlagsKHR
rotate :: VkXlibSurfaceCreateFlagsKHR -> Int -> VkXlibSurfaceCreateFlagsKHR
$crotate :: VkXlibSurfaceCreateFlagsKHR -> Int -> VkXlibSurfaceCreateFlagsKHR
shift :: VkXlibSurfaceCreateFlagsKHR -> Int -> VkXlibSurfaceCreateFlagsKHR
$cshift :: VkXlibSurfaceCreateFlagsKHR -> Int -> VkXlibSurfaceCreateFlagsKHR
complement :: VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR
$ccomplement :: VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR
xor :: VkXlibSurfaceCreateFlagsKHR
-> VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR
$cxor :: VkXlibSurfaceCreateFlagsKHR
-> VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR
.|. :: VkXlibSurfaceCreateFlagsKHR
-> VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR
$c.|. :: VkXlibSurfaceCreateFlagsKHR
-> VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR
.&. :: VkXlibSurfaceCreateFlagsKHR
-> VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR
$c.&. :: VkXlibSurfaceCreateFlagsKHR
-> VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR
Bits, Bits VkXlibSurfaceCreateFlagsKHR
Bits VkXlibSurfaceCreateFlagsKHR
-> (VkXlibSurfaceCreateFlagsKHR -> Int)
-> (VkXlibSurfaceCreateFlagsKHR -> Int)
-> (VkXlibSurfaceCreateFlagsKHR -> Int)
-> FiniteBits VkXlibSurfaceCreateFlagsKHR
VkXlibSurfaceCreateFlagsKHR -> Int
forall b.
Bits b -> (b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
countTrailingZeros :: VkXlibSurfaceCreateFlagsKHR -> Int
$ccountTrailingZeros :: VkXlibSurfaceCreateFlagsKHR -> Int
countLeadingZeros :: VkXlibSurfaceCreateFlagsKHR -> Int
$ccountLeadingZeros :: VkXlibSurfaceCreateFlagsKHR -> Int
finiteBitSize :: VkXlibSurfaceCreateFlagsKHR -> Int
$cfiniteBitSize :: VkXlibSurfaceCreateFlagsKHR -> Int
FiniteBits, Ptr VkXlibSurfaceCreateFlagsKHR -> IO VkXlibSurfaceCreateFlagsKHR
Ptr VkXlibSurfaceCreateFlagsKHR
-> Int -> IO VkXlibSurfaceCreateFlagsKHR
Ptr VkXlibSurfaceCreateFlagsKHR
-> Int -> VkXlibSurfaceCreateFlagsKHR -> IO ()
Ptr VkXlibSurfaceCreateFlagsKHR
-> VkXlibSurfaceCreateFlagsKHR -> IO ()
VkXlibSurfaceCreateFlagsKHR -> Int
(VkXlibSurfaceCreateFlagsKHR -> Int)
-> (VkXlibSurfaceCreateFlagsKHR -> Int)
-> (Ptr VkXlibSurfaceCreateFlagsKHR
    -> Int -> IO VkXlibSurfaceCreateFlagsKHR)
-> (Ptr VkXlibSurfaceCreateFlagsKHR
    -> Int -> VkXlibSurfaceCreateFlagsKHR -> IO ())
-> (forall b. Ptr b -> Int -> IO VkXlibSurfaceCreateFlagsKHR)
-> (forall b. Ptr b -> Int -> VkXlibSurfaceCreateFlagsKHR -> IO ())
-> (Ptr VkXlibSurfaceCreateFlagsKHR
    -> IO VkXlibSurfaceCreateFlagsKHR)
-> (Ptr VkXlibSurfaceCreateFlagsKHR
    -> VkXlibSurfaceCreateFlagsKHR -> IO ())
-> Storable VkXlibSurfaceCreateFlagsKHR
forall b. Ptr b -> Int -> IO VkXlibSurfaceCreateFlagsKHR
forall b. Ptr b -> Int -> VkXlibSurfaceCreateFlagsKHR -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr VkXlibSurfaceCreateFlagsKHR
-> VkXlibSurfaceCreateFlagsKHR -> IO ()
$cpoke :: Ptr VkXlibSurfaceCreateFlagsKHR
-> VkXlibSurfaceCreateFlagsKHR -> IO ()
peek :: Ptr VkXlibSurfaceCreateFlagsKHR -> IO VkXlibSurfaceCreateFlagsKHR
$cpeek :: Ptr VkXlibSurfaceCreateFlagsKHR -> IO VkXlibSurfaceCreateFlagsKHR
pokeByteOff :: forall b. Ptr b -> Int -> VkXlibSurfaceCreateFlagsKHR -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> VkXlibSurfaceCreateFlagsKHR -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO VkXlibSurfaceCreateFlagsKHR
$cpeekByteOff :: forall b. Ptr b -> Int -> IO VkXlibSurfaceCreateFlagsKHR
pokeElemOff :: Ptr VkXlibSurfaceCreateFlagsKHR
-> Int -> VkXlibSurfaceCreateFlagsKHR -> IO ()
$cpokeElemOff :: Ptr VkXlibSurfaceCreateFlagsKHR
-> Int -> VkXlibSurfaceCreateFlagsKHR -> IO ()
peekElemOff :: Ptr VkXlibSurfaceCreateFlagsKHR
-> Int -> IO VkXlibSurfaceCreateFlagsKHR
$cpeekElemOff :: Ptr VkXlibSurfaceCreateFlagsKHR
-> Int -> IO VkXlibSurfaceCreateFlagsKHR
alignment :: VkXlibSurfaceCreateFlagsKHR -> Int
$calignment :: VkXlibSurfaceCreateFlagsKHR -> Int
sizeOf :: VkXlibSurfaceCreateFlagsKHR -> Int
$csizeOf :: VkXlibSurfaceCreateFlagsKHR -> Int
Storable)

instance Show VkXlibSurfaceCreateFlagsKHR where
    {-# INLINE showsPrec #-}
    showsPrec :: Int -> VkXlibSurfaceCreateFlagsKHR -> ShowS
showsPrec = (Int -> VkFlags -> ShowS)
-> Int -> VkXlibSurfaceCreateFlagsKHR -> ShowS
coerce (Int -> VkFlags -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec :: Int -> VkFlags -> ShowS)

instance Read VkXlibSurfaceCreateFlagsKHR where
    {-# INLINE readsPrec #-}
    readsPrec :: Int -> ReadS VkXlibSurfaceCreateFlagsKHR
readsPrec = (Int -> ReadS VkFlags) -> Int -> ReadS VkXlibSurfaceCreateFlagsKHR
coerce (Int -> ReadS VkFlags
forall a. Read a => Int -> ReadS a
readsPrec :: Int -> ReadS VkFlags)