{-# LANGUAGE DataKinds                  #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE Strict                     #-}
module Graphics.Vulkan.Types.BaseTypes
       (AHardwareBuffer(), ANativeWindow(), CAMetalLayer(), VkBool32(..),
        VkDeviceAddress(..), VkDeviceSize(..), VkFlags(..),
        VkSampleMask(..))
       where
import Data.Bits               (Bits, FiniteBits)
import Data.Coerce             (coerce)
import Foreign.Storable        (Storable)
import Graphics.Vulkan.Marshal (Word32, Word64)

-- | > struct AHardwareBuffer;
data AHardwareBuffer

-- | > struct ANativeWindow;
data ANativeWindow

-- | >
--   > #ifdef __OBJC__
--   > @class CAMetalLayer;
--   > #else
--   > typedef void CAMetalLayer;
--   > #endif
data CAMetalLayer

newtype VkBool32 = VkBool32 Word32
                   deriving (VkBool32 -> VkBool32 -> Bool
(VkBool32 -> VkBool32 -> Bool)
-> (VkBool32 -> VkBool32 -> Bool) -> Eq VkBool32
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VkBool32 -> VkBool32 -> Bool
$c/= :: VkBool32 -> VkBool32 -> Bool
== :: VkBool32 -> VkBool32 -> Bool
$c== :: VkBool32 -> VkBool32 -> Bool
Eq, Eq VkBool32
Eq VkBool32
-> (VkBool32 -> VkBool32 -> Ordering)
-> (VkBool32 -> VkBool32 -> Bool)
-> (VkBool32 -> VkBool32 -> Bool)
-> (VkBool32 -> VkBool32 -> Bool)
-> (VkBool32 -> VkBool32 -> Bool)
-> (VkBool32 -> VkBool32 -> VkBool32)
-> (VkBool32 -> VkBool32 -> VkBool32)
-> Ord VkBool32
VkBool32 -> VkBool32 -> Bool
VkBool32 -> VkBool32 -> Ordering
VkBool32 -> VkBool32 -> VkBool32
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 :: VkBool32 -> VkBool32 -> VkBool32
$cmin :: VkBool32 -> VkBool32 -> VkBool32
max :: VkBool32 -> VkBool32 -> VkBool32
$cmax :: VkBool32 -> VkBool32 -> VkBool32
>= :: VkBool32 -> VkBool32 -> Bool
$c>= :: VkBool32 -> VkBool32 -> Bool
> :: VkBool32 -> VkBool32 -> Bool
$c> :: VkBool32 -> VkBool32 -> Bool
<= :: VkBool32 -> VkBool32 -> Bool
$c<= :: VkBool32 -> VkBool32 -> Bool
< :: VkBool32 -> VkBool32 -> Bool
$c< :: VkBool32 -> VkBool32 -> Bool
compare :: VkBool32 -> VkBool32 -> Ordering
$ccompare :: VkBool32 -> VkBool32 -> Ordering
Ord, Integer -> VkBool32
VkBool32 -> VkBool32
VkBool32 -> VkBool32 -> VkBool32
(VkBool32 -> VkBool32 -> VkBool32)
-> (VkBool32 -> VkBool32 -> VkBool32)
-> (VkBool32 -> VkBool32 -> VkBool32)
-> (VkBool32 -> VkBool32)
-> (VkBool32 -> VkBool32)
-> (VkBool32 -> VkBool32)
-> (Integer -> VkBool32)
-> Num VkBool32
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
fromInteger :: Integer -> VkBool32
$cfromInteger :: Integer -> VkBool32
signum :: VkBool32 -> VkBool32
$csignum :: VkBool32 -> VkBool32
abs :: VkBool32 -> VkBool32
$cabs :: VkBool32 -> VkBool32
negate :: VkBool32 -> VkBool32
$cnegate :: VkBool32 -> VkBool32
* :: VkBool32 -> VkBool32 -> VkBool32
$c* :: VkBool32 -> VkBool32 -> VkBool32
- :: VkBool32 -> VkBool32 -> VkBool32
$c- :: VkBool32 -> VkBool32 -> VkBool32
+ :: VkBool32 -> VkBool32 -> VkBool32
$c+ :: VkBool32 -> VkBool32 -> VkBool32
Num, VkBool32
VkBool32 -> VkBool32 -> Bounded VkBool32
forall a. a -> a -> Bounded a
maxBound :: VkBool32
$cmaxBound :: VkBool32
minBound :: VkBool32
$cminBound :: VkBool32
Bounded, Int -> VkBool32
VkBool32 -> Int
VkBool32 -> [VkBool32]
VkBool32 -> VkBool32
VkBool32 -> VkBool32 -> [VkBool32]
VkBool32 -> VkBool32 -> VkBool32 -> [VkBool32]
(VkBool32 -> VkBool32)
-> (VkBool32 -> VkBool32)
-> (Int -> VkBool32)
-> (VkBool32 -> Int)
-> (VkBool32 -> [VkBool32])
-> (VkBool32 -> VkBool32 -> [VkBool32])
-> (VkBool32 -> VkBool32 -> [VkBool32])
-> (VkBool32 -> VkBool32 -> VkBool32 -> [VkBool32])
-> Enum VkBool32
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 :: VkBool32 -> VkBool32 -> VkBool32 -> [VkBool32]
$cenumFromThenTo :: VkBool32 -> VkBool32 -> VkBool32 -> [VkBool32]
enumFromTo :: VkBool32 -> VkBool32 -> [VkBool32]
$cenumFromTo :: VkBool32 -> VkBool32 -> [VkBool32]
enumFromThen :: VkBool32 -> VkBool32 -> [VkBool32]
$cenumFromThen :: VkBool32 -> VkBool32 -> [VkBool32]
enumFrom :: VkBool32 -> [VkBool32]
$cenumFrom :: VkBool32 -> [VkBool32]
fromEnum :: VkBool32 -> Int
$cfromEnum :: VkBool32 -> Int
toEnum :: Int -> VkBool32
$ctoEnum :: Int -> VkBool32
pred :: VkBool32 -> VkBool32
$cpred :: VkBool32 -> VkBool32
succ :: VkBool32 -> VkBool32
$csucc :: VkBool32 -> VkBool32
Enum, Enum VkBool32
Real VkBool32
Real VkBool32
-> Enum VkBool32
-> (VkBool32 -> VkBool32 -> VkBool32)
-> (VkBool32 -> VkBool32 -> VkBool32)
-> (VkBool32 -> VkBool32 -> VkBool32)
-> (VkBool32 -> VkBool32 -> VkBool32)
-> (VkBool32 -> VkBool32 -> (VkBool32, VkBool32))
-> (VkBool32 -> VkBool32 -> (VkBool32, VkBool32))
-> (VkBool32 -> Integer)
-> Integral VkBool32
VkBool32 -> Integer
VkBool32 -> VkBool32 -> (VkBool32, VkBool32)
VkBool32 -> VkBool32 -> VkBool32
forall a.
Real a
-> Enum a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> (a, a))
-> (a -> a -> (a, a))
-> (a -> Integer)
-> Integral a
toInteger :: VkBool32 -> Integer
$ctoInteger :: VkBool32 -> Integer
divMod :: VkBool32 -> VkBool32 -> (VkBool32, VkBool32)
$cdivMod :: VkBool32 -> VkBool32 -> (VkBool32, VkBool32)
quotRem :: VkBool32 -> VkBool32 -> (VkBool32, VkBool32)
$cquotRem :: VkBool32 -> VkBool32 -> (VkBool32, VkBool32)
mod :: VkBool32 -> VkBool32 -> VkBool32
$cmod :: VkBool32 -> VkBool32 -> VkBool32
div :: VkBool32 -> VkBool32 -> VkBool32
$cdiv :: VkBool32 -> VkBool32 -> VkBool32
rem :: VkBool32 -> VkBool32 -> VkBool32
$crem :: VkBool32 -> VkBool32 -> VkBool32
quot :: VkBool32 -> VkBool32 -> VkBool32
$cquot :: VkBool32 -> VkBool32 -> VkBool32
Integral, Num VkBool32
Ord VkBool32
Num VkBool32
-> Ord VkBool32 -> (VkBool32 -> Rational) -> Real VkBool32
VkBool32 -> Rational
forall a. Num a -> Ord a -> (a -> Rational) -> Real a
toRational :: VkBool32 -> Rational
$ctoRational :: VkBool32 -> Rational
Real, Eq VkBool32
VkBool32
Eq VkBool32
-> (VkBool32 -> VkBool32 -> VkBool32)
-> (VkBool32 -> VkBool32 -> VkBool32)
-> (VkBool32 -> VkBool32 -> VkBool32)
-> (VkBool32 -> VkBool32)
-> (VkBool32 -> Int -> VkBool32)
-> (VkBool32 -> Int -> VkBool32)
-> VkBool32
-> (Int -> VkBool32)
-> (VkBool32 -> Int -> VkBool32)
-> (VkBool32 -> Int -> VkBool32)
-> (VkBool32 -> Int -> VkBool32)
-> (VkBool32 -> Int -> Bool)
-> (VkBool32 -> Maybe Int)
-> (VkBool32 -> Int)
-> (VkBool32 -> Bool)
-> (VkBool32 -> Int -> VkBool32)
-> (VkBool32 -> Int -> VkBool32)
-> (VkBool32 -> Int -> VkBool32)
-> (VkBool32 -> Int -> VkBool32)
-> (VkBool32 -> Int -> VkBool32)
-> (VkBool32 -> Int -> VkBool32)
-> (VkBool32 -> Int)
-> Bits VkBool32
Int -> VkBool32
VkBool32 -> Bool
VkBool32 -> Int
VkBool32 -> Maybe Int
VkBool32 -> VkBool32
VkBool32 -> Int -> Bool
VkBool32 -> Int -> VkBool32
VkBool32 -> VkBool32 -> VkBool32
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 :: VkBool32 -> Int
$cpopCount :: VkBool32 -> Int
rotateR :: VkBool32 -> Int -> VkBool32
$crotateR :: VkBool32 -> Int -> VkBool32
rotateL :: VkBool32 -> Int -> VkBool32
$crotateL :: VkBool32 -> Int -> VkBool32
unsafeShiftR :: VkBool32 -> Int -> VkBool32
$cunsafeShiftR :: VkBool32 -> Int -> VkBool32
shiftR :: VkBool32 -> Int -> VkBool32
$cshiftR :: VkBool32 -> Int -> VkBool32
unsafeShiftL :: VkBool32 -> Int -> VkBool32
$cunsafeShiftL :: VkBool32 -> Int -> VkBool32
shiftL :: VkBool32 -> Int -> VkBool32
$cshiftL :: VkBool32 -> Int -> VkBool32
isSigned :: VkBool32 -> Bool
$cisSigned :: VkBool32 -> Bool
bitSize :: VkBool32 -> Int
$cbitSize :: VkBool32 -> Int
bitSizeMaybe :: VkBool32 -> Maybe Int
$cbitSizeMaybe :: VkBool32 -> Maybe Int
testBit :: VkBool32 -> Int -> Bool
$ctestBit :: VkBool32 -> Int -> Bool
complementBit :: VkBool32 -> Int -> VkBool32
$ccomplementBit :: VkBool32 -> Int -> VkBool32
clearBit :: VkBool32 -> Int -> VkBool32
$cclearBit :: VkBool32 -> Int -> VkBool32
setBit :: VkBool32 -> Int -> VkBool32
$csetBit :: VkBool32 -> Int -> VkBool32
bit :: Int -> VkBool32
$cbit :: Int -> VkBool32
zeroBits :: VkBool32
$czeroBits :: VkBool32
rotate :: VkBool32 -> Int -> VkBool32
$crotate :: VkBool32 -> Int -> VkBool32
shift :: VkBool32 -> Int -> VkBool32
$cshift :: VkBool32 -> Int -> VkBool32
complement :: VkBool32 -> VkBool32
$ccomplement :: VkBool32 -> VkBool32
xor :: VkBool32 -> VkBool32 -> VkBool32
$cxor :: VkBool32 -> VkBool32 -> VkBool32
.|. :: VkBool32 -> VkBool32 -> VkBool32
$c.|. :: VkBool32 -> VkBool32 -> VkBool32
.&. :: VkBool32 -> VkBool32 -> VkBool32
$c.&. :: VkBool32 -> VkBool32 -> VkBool32
Bits,
                             Bits VkBool32
Bits VkBool32
-> (VkBool32 -> Int)
-> (VkBool32 -> Int)
-> (VkBool32 -> Int)
-> FiniteBits VkBool32
VkBool32 -> Int
forall b.
Bits b -> (b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
countTrailingZeros :: VkBool32 -> Int
$ccountTrailingZeros :: VkBool32 -> Int
countLeadingZeros :: VkBool32 -> Int
$ccountLeadingZeros :: VkBool32 -> Int
finiteBitSize :: VkBool32 -> Int
$cfiniteBitSize :: VkBool32 -> Int
FiniteBits, Ptr VkBool32 -> IO VkBool32
Ptr VkBool32 -> Int -> IO VkBool32
Ptr VkBool32 -> Int -> VkBool32 -> IO ()
Ptr VkBool32 -> VkBool32 -> IO ()
VkBool32 -> Int
(VkBool32 -> Int)
-> (VkBool32 -> Int)
-> (Ptr VkBool32 -> Int -> IO VkBool32)
-> (Ptr VkBool32 -> Int -> VkBool32 -> IO ())
-> (forall b. Ptr b -> Int -> IO VkBool32)
-> (forall b. Ptr b -> Int -> VkBool32 -> IO ())
-> (Ptr VkBool32 -> IO VkBool32)
-> (Ptr VkBool32 -> VkBool32 -> IO ())
-> Storable VkBool32
forall b. Ptr b -> Int -> IO VkBool32
forall b. Ptr b -> Int -> VkBool32 -> 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 VkBool32 -> VkBool32 -> IO ()
$cpoke :: Ptr VkBool32 -> VkBool32 -> IO ()
peek :: Ptr VkBool32 -> IO VkBool32
$cpeek :: Ptr VkBool32 -> IO VkBool32
pokeByteOff :: forall b. Ptr b -> Int -> VkBool32 -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> VkBool32 -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO VkBool32
$cpeekByteOff :: forall b. Ptr b -> Int -> IO VkBool32
pokeElemOff :: Ptr VkBool32 -> Int -> VkBool32 -> IO ()
$cpokeElemOff :: Ptr VkBool32 -> Int -> VkBool32 -> IO ()
peekElemOff :: Ptr VkBool32 -> Int -> IO VkBool32
$cpeekElemOff :: Ptr VkBool32 -> Int -> IO VkBool32
alignment :: VkBool32 -> Int
$calignment :: VkBool32 -> Int
sizeOf :: VkBool32 -> Int
$csizeOf :: VkBool32 -> Int
Storable)

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

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

newtype VkDeviceAddress = VkDeviceAddress Word64
                          deriving (VkDeviceAddress -> VkDeviceAddress -> Bool
(VkDeviceAddress -> VkDeviceAddress -> Bool)
-> (VkDeviceAddress -> VkDeviceAddress -> Bool)
-> Eq VkDeviceAddress
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VkDeviceAddress -> VkDeviceAddress -> Bool
$c/= :: VkDeviceAddress -> VkDeviceAddress -> Bool
== :: VkDeviceAddress -> VkDeviceAddress -> Bool
$c== :: VkDeviceAddress -> VkDeviceAddress -> Bool
Eq, Eq VkDeviceAddress
Eq VkDeviceAddress
-> (VkDeviceAddress -> VkDeviceAddress -> Ordering)
-> (VkDeviceAddress -> VkDeviceAddress -> Bool)
-> (VkDeviceAddress -> VkDeviceAddress -> Bool)
-> (VkDeviceAddress -> VkDeviceAddress -> Bool)
-> (VkDeviceAddress -> VkDeviceAddress -> Bool)
-> (VkDeviceAddress -> VkDeviceAddress -> VkDeviceAddress)
-> (VkDeviceAddress -> VkDeviceAddress -> VkDeviceAddress)
-> Ord VkDeviceAddress
VkDeviceAddress -> VkDeviceAddress -> Bool
VkDeviceAddress -> VkDeviceAddress -> Ordering
VkDeviceAddress -> VkDeviceAddress -> VkDeviceAddress
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 :: VkDeviceAddress -> VkDeviceAddress -> VkDeviceAddress
$cmin :: VkDeviceAddress -> VkDeviceAddress -> VkDeviceAddress
max :: VkDeviceAddress -> VkDeviceAddress -> VkDeviceAddress
$cmax :: VkDeviceAddress -> VkDeviceAddress -> VkDeviceAddress
>= :: VkDeviceAddress -> VkDeviceAddress -> Bool
$c>= :: VkDeviceAddress -> VkDeviceAddress -> Bool
> :: VkDeviceAddress -> VkDeviceAddress -> Bool
$c> :: VkDeviceAddress -> VkDeviceAddress -> Bool
<= :: VkDeviceAddress -> VkDeviceAddress -> Bool
$c<= :: VkDeviceAddress -> VkDeviceAddress -> Bool
< :: VkDeviceAddress -> VkDeviceAddress -> Bool
$c< :: VkDeviceAddress -> VkDeviceAddress -> Bool
compare :: VkDeviceAddress -> VkDeviceAddress -> Ordering
$ccompare :: VkDeviceAddress -> VkDeviceAddress -> Ordering
Ord, Integer -> VkDeviceAddress
VkDeviceAddress -> VkDeviceAddress
VkDeviceAddress -> VkDeviceAddress -> VkDeviceAddress
(VkDeviceAddress -> VkDeviceAddress -> VkDeviceAddress)
-> (VkDeviceAddress -> VkDeviceAddress -> VkDeviceAddress)
-> (VkDeviceAddress -> VkDeviceAddress -> VkDeviceAddress)
-> (VkDeviceAddress -> VkDeviceAddress)
-> (VkDeviceAddress -> VkDeviceAddress)
-> (VkDeviceAddress -> VkDeviceAddress)
-> (Integer -> VkDeviceAddress)
-> Num VkDeviceAddress
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
fromInteger :: Integer -> VkDeviceAddress
$cfromInteger :: Integer -> VkDeviceAddress
signum :: VkDeviceAddress -> VkDeviceAddress
$csignum :: VkDeviceAddress -> VkDeviceAddress
abs :: VkDeviceAddress -> VkDeviceAddress
$cabs :: VkDeviceAddress -> VkDeviceAddress
negate :: VkDeviceAddress -> VkDeviceAddress
$cnegate :: VkDeviceAddress -> VkDeviceAddress
* :: VkDeviceAddress -> VkDeviceAddress -> VkDeviceAddress
$c* :: VkDeviceAddress -> VkDeviceAddress -> VkDeviceAddress
- :: VkDeviceAddress -> VkDeviceAddress -> VkDeviceAddress
$c- :: VkDeviceAddress -> VkDeviceAddress -> VkDeviceAddress
+ :: VkDeviceAddress -> VkDeviceAddress -> VkDeviceAddress
$c+ :: VkDeviceAddress -> VkDeviceAddress -> VkDeviceAddress
Num, VkDeviceAddress
VkDeviceAddress -> VkDeviceAddress -> Bounded VkDeviceAddress
forall a. a -> a -> Bounded a
maxBound :: VkDeviceAddress
$cmaxBound :: VkDeviceAddress
minBound :: VkDeviceAddress
$cminBound :: VkDeviceAddress
Bounded, Int -> VkDeviceAddress
VkDeviceAddress -> Int
VkDeviceAddress -> [VkDeviceAddress]
VkDeviceAddress -> VkDeviceAddress
VkDeviceAddress -> VkDeviceAddress -> [VkDeviceAddress]
VkDeviceAddress
-> VkDeviceAddress -> VkDeviceAddress -> [VkDeviceAddress]
(VkDeviceAddress -> VkDeviceAddress)
-> (VkDeviceAddress -> VkDeviceAddress)
-> (Int -> VkDeviceAddress)
-> (VkDeviceAddress -> Int)
-> (VkDeviceAddress -> [VkDeviceAddress])
-> (VkDeviceAddress -> VkDeviceAddress -> [VkDeviceAddress])
-> (VkDeviceAddress -> VkDeviceAddress -> [VkDeviceAddress])
-> (VkDeviceAddress
    -> VkDeviceAddress -> VkDeviceAddress -> [VkDeviceAddress])
-> Enum VkDeviceAddress
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 :: VkDeviceAddress
-> VkDeviceAddress -> VkDeviceAddress -> [VkDeviceAddress]
$cenumFromThenTo :: VkDeviceAddress
-> VkDeviceAddress -> VkDeviceAddress -> [VkDeviceAddress]
enumFromTo :: VkDeviceAddress -> VkDeviceAddress -> [VkDeviceAddress]
$cenumFromTo :: VkDeviceAddress -> VkDeviceAddress -> [VkDeviceAddress]
enumFromThen :: VkDeviceAddress -> VkDeviceAddress -> [VkDeviceAddress]
$cenumFromThen :: VkDeviceAddress -> VkDeviceAddress -> [VkDeviceAddress]
enumFrom :: VkDeviceAddress -> [VkDeviceAddress]
$cenumFrom :: VkDeviceAddress -> [VkDeviceAddress]
fromEnum :: VkDeviceAddress -> Int
$cfromEnum :: VkDeviceAddress -> Int
toEnum :: Int -> VkDeviceAddress
$ctoEnum :: Int -> VkDeviceAddress
pred :: VkDeviceAddress -> VkDeviceAddress
$cpred :: VkDeviceAddress -> VkDeviceAddress
succ :: VkDeviceAddress -> VkDeviceAddress
$csucc :: VkDeviceAddress -> VkDeviceAddress
Enum, Enum VkDeviceAddress
Real VkDeviceAddress
Real VkDeviceAddress
-> Enum VkDeviceAddress
-> (VkDeviceAddress -> VkDeviceAddress -> VkDeviceAddress)
-> (VkDeviceAddress -> VkDeviceAddress -> VkDeviceAddress)
-> (VkDeviceAddress -> VkDeviceAddress -> VkDeviceAddress)
-> (VkDeviceAddress -> VkDeviceAddress -> VkDeviceAddress)
-> (VkDeviceAddress
    -> VkDeviceAddress -> (VkDeviceAddress, VkDeviceAddress))
-> (VkDeviceAddress
    -> VkDeviceAddress -> (VkDeviceAddress, VkDeviceAddress))
-> (VkDeviceAddress -> Integer)
-> Integral VkDeviceAddress
VkDeviceAddress -> Integer
VkDeviceAddress
-> VkDeviceAddress -> (VkDeviceAddress, VkDeviceAddress)
VkDeviceAddress -> VkDeviceAddress -> VkDeviceAddress
forall a.
Real a
-> Enum a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> (a, a))
-> (a -> a -> (a, a))
-> (a -> Integer)
-> Integral a
toInteger :: VkDeviceAddress -> Integer
$ctoInteger :: VkDeviceAddress -> Integer
divMod :: VkDeviceAddress
-> VkDeviceAddress -> (VkDeviceAddress, VkDeviceAddress)
$cdivMod :: VkDeviceAddress
-> VkDeviceAddress -> (VkDeviceAddress, VkDeviceAddress)
quotRem :: VkDeviceAddress
-> VkDeviceAddress -> (VkDeviceAddress, VkDeviceAddress)
$cquotRem :: VkDeviceAddress
-> VkDeviceAddress -> (VkDeviceAddress, VkDeviceAddress)
mod :: VkDeviceAddress -> VkDeviceAddress -> VkDeviceAddress
$cmod :: VkDeviceAddress -> VkDeviceAddress -> VkDeviceAddress
div :: VkDeviceAddress -> VkDeviceAddress -> VkDeviceAddress
$cdiv :: VkDeviceAddress -> VkDeviceAddress -> VkDeviceAddress
rem :: VkDeviceAddress -> VkDeviceAddress -> VkDeviceAddress
$crem :: VkDeviceAddress -> VkDeviceAddress -> VkDeviceAddress
quot :: VkDeviceAddress -> VkDeviceAddress -> VkDeviceAddress
$cquot :: VkDeviceAddress -> VkDeviceAddress -> VkDeviceAddress
Integral, Num VkDeviceAddress
Ord VkDeviceAddress
Num VkDeviceAddress
-> Ord VkDeviceAddress
-> (VkDeviceAddress -> Rational)
-> Real VkDeviceAddress
VkDeviceAddress -> Rational
forall a. Num a -> Ord a -> (a -> Rational) -> Real a
toRational :: VkDeviceAddress -> Rational
$ctoRational :: VkDeviceAddress -> Rational
Real, Eq VkDeviceAddress
VkDeviceAddress
Eq VkDeviceAddress
-> (VkDeviceAddress -> VkDeviceAddress -> VkDeviceAddress)
-> (VkDeviceAddress -> VkDeviceAddress -> VkDeviceAddress)
-> (VkDeviceAddress -> VkDeviceAddress -> VkDeviceAddress)
-> (VkDeviceAddress -> VkDeviceAddress)
-> (VkDeviceAddress -> Int -> VkDeviceAddress)
-> (VkDeviceAddress -> Int -> VkDeviceAddress)
-> VkDeviceAddress
-> (Int -> VkDeviceAddress)
-> (VkDeviceAddress -> Int -> VkDeviceAddress)
-> (VkDeviceAddress -> Int -> VkDeviceAddress)
-> (VkDeviceAddress -> Int -> VkDeviceAddress)
-> (VkDeviceAddress -> Int -> Bool)
-> (VkDeviceAddress -> Maybe Int)
-> (VkDeviceAddress -> Int)
-> (VkDeviceAddress -> Bool)
-> (VkDeviceAddress -> Int -> VkDeviceAddress)
-> (VkDeviceAddress -> Int -> VkDeviceAddress)
-> (VkDeviceAddress -> Int -> VkDeviceAddress)
-> (VkDeviceAddress -> Int -> VkDeviceAddress)
-> (VkDeviceAddress -> Int -> VkDeviceAddress)
-> (VkDeviceAddress -> Int -> VkDeviceAddress)
-> (VkDeviceAddress -> Int)
-> Bits VkDeviceAddress
Int -> VkDeviceAddress
VkDeviceAddress -> Bool
VkDeviceAddress -> Int
VkDeviceAddress -> Maybe Int
VkDeviceAddress -> VkDeviceAddress
VkDeviceAddress -> Int -> Bool
VkDeviceAddress -> Int -> VkDeviceAddress
VkDeviceAddress -> VkDeviceAddress -> VkDeviceAddress
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 :: VkDeviceAddress -> Int
$cpopCount :: VkDeviceAddress -> Int
rotateR :: VkDeviceAddress -> Int -> VkDeviceAddress
$crotateR :: VkDeviceAddress -> Int -> VkDeviceAddress
rotateL :: VkDeviceAddress -> Int -> VkDeviceAddress
$crotateL :: VkDeviceAddress -> Int -> VkDeviceAddress
unsafeShiftR :: VkDeviceAddress -> Int -> VkDeviceAddress
$cunsafeShiftR :: VkDeviceAddress -> Int -> VkDeviceAddress
shiftR :: VkDeviceAddress -> Int -> VkDeviceAddress
$cshiftR :: VkDeviceAddress -> Int -> VkDeviceAddress
unsafeShiftL :: VkDeviceAddress -> Int -> VkDeviceAddress
$cunsafeShiftL :: VkDeviceAddress -> Int -> VkDeviceAddress
shiftL :: VkDeviceAddress -> Int -> VkDeviceAddress
$cshiftL :: VkDeviceAddress -> Int -> VkDeviceAddress
isSigned :: VkDeviceAddress -> Bool
$cisSigned :: VkDeviceAddress -> Bool
bitSize :: VkDeviceAddress -> Int
$cbitSize :: VkDeviceAddress -> Int
bitSizeMaybe :: VkDeviceAddress -> Maybe Int
$cbitSizeMaybe :: VkDeviceAddress -> Maybe Int
testBit :: VkDeviceAddress -> Int -> Bool
$ctestBit :: VkDeviceAddress -> Int -> Bool
complementBit :: VkDeviceAddress -> Int -> VkDeviceAddress
$ccomplementBit :: VkDeviceAddress -> Int -> VkDeviceAddress
clearBit :: VkDeviceAddress -> Int -> VkDeviceAddress
$cclearBit :: VkDeviceAddress -> Int -> VkDeviceAddress
setBit :: VkDeviceAddress -> Int -> VkDeviceAddress
$csetBit :: VkDeviceAddress -> Int -> VkDeviceAddress
bit :: Int -> VkDeviceAddress
$cbit :: Int -> VkDeviceAddress
zeroBits :: VkDeviceAddress
$czeroBits :: VkDeviceAddress
rotate :: VkDeviceAddress -> Int -> VkDeviceAddress
$crotate :: VkDeviceAddress -> Int -> VkDeviceAddress
shift :: VkDeviceAddress -> Int -> VkDeviceAddress
$cshift :: VkDeviceAddress -> Int -> VkDeviceAddress
complement :: VkDeviceAddress -> VkDeviceAddress
$ccomplement :: VkDeviceAddress -> VkDeviceAddress
xor :: VkDeviceAddress -> VkDeviceAddress -> VkDeviceAddress
$cxor :: VkDeviceAddress -> VkDeviceAddress -> VkDeviceAddress
.|. :: VkDeviceAddress -> VkDeviceAddress -> VkDeviceAddress
$c.|. :: VkDeviceAddress -> VkDeviceAddress -> VkDeviceAddress
.&. :: VkDeviceAddress -> VkDeviceAddress -> VkDeviceAddress
$c.&. :: VkDeviceAddress -> VkDeviceAddress -> VkDeviceAddress
Bits,
                                    Bits VkDeviceAddress
Bits VkDeviceAddress
-> (VkDeviceAddress -> Int)
-> (VkDeviceAddress -> Int)
-> (VkDeviceAddress -> Int)
-> FiniteBits VkDeviceAddress
VkDeviceAddress -> Int
forall b.
Bits b -> (b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
countTrailingZeros :: VkDeviceAddress -> Int
$ccountTrailingZeros :: VkDeviceAddress -> Int
countLeadingZeros :: VkDeviceAddress -> Int
$ccountLeadingZeros :: VkDeviceAddress -> Int
finiteBitSize :: VkDeviceAddress -> Int
$cfiniteBitSize :: VkDeviceAddress -> Int
FiniteBits, Ptr VkDeviceAddress -> IO VkDeviceAddress
Ptr VkDeviceAddress -> Int -> IO VkDeviceAddress
Ptr VkDeviceAddress -> Int -> VkDeviceAddress -> IO ()
Ptr VkDeviceAddress -> VkDeviceAddress -> IO ()
VkDeviceAddress -> Int
(VkDeviceAddress -> Int)
-> (VkDeviceAddress -> Int)
-> (Ptr VkDeviceAddress -> Int -> IO VkDeviceAddress)
-> (Ptr VkDeviceAddress -> Int -> VkDeviceAddress -> IO ())
-> (forall b. Ptr b -> Int -> IO VkDeviceAddress)
-> (forall b. Ptr b -> Int -> VkDeviceAddress -> IO ())
-> (Ptr VkDeviceAddress -> IO VkDeviceAddress)
-> (Ptr VkDeviceAddress -> VkDeviceAddress -> IO ())
-> Storable VkDeviceAddress
forall b. Ptr b -> Int -> IO VkDeviceAddress
forall b. Ptr b -> Int -> VkDeviceAddress -> 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 VkDeviceAddress -> VkDeviceAddress -> IO ()
$cpoke :: Ptr VkDeviceAddress -> VkDeviceAddress -> IO ()
peek :: Ptr VkDeviceAddress -> IO VkDeviceAddress
$cpeek :: Ptr VkDeviceAddress -> IO VkDeviceAddress
pokeByteOff :: forall b. Ptr b -> Int -> VkDeviceAddress -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> VkDeviceAddress -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO VkDeviceAddress
$cpeekByteOff :: forall b. Ptr b -> Int -> IO VkDeviceAddress
pokeElemOff :: Ptr VkDeviceAddress -> Int -> VkDeviceAddress -> IO ()
$cpokeElemOff :: Ptr VkDeviceAddress -> Int -> VkDeviceAddress -> IO ()
peekElemOff :: Ptr VkDeviceAddress -> Int -> IO VkDeviceAddress
$cpeekElemOff :: Ptr VkDeviceAddress -> Int -> IO VkDeviceAddress
alignment :: VkDeviceAddress -> Int
$calignment :: VkDeviceAddress -> Int
sizeOf :: VkDeviceAddress -> Int
$csizeOf :: VkDeviceAddress -> Int
Storable)

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

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

newtype VkDeviceSize = VkDeviceSize Word64
                       deriving (VkDeviceSize -> VkDeviceSize -> Bool
(VkDeviceSize -> VkDeviceSize -> Bool)
-> (VkDeviceSize -> VkDeviceSize -> Bool) -> Eq VkDeviceSize
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VkDeviceSize -> VkDeviceSize -> Bool
$c/= :: VkDeviceSize -> VkDeviceSize -> Bool
== :: VkDeviceSize -> VkDeviceSize -> Bool
$c== :: VkDeviceSize -> VkDeviceSize -> Bool
Eq, Eq VkDeviceSize
Eq VkDeviceSize
-> (VkDeviceSize -> VkDeviceSize -> Ordering)
-> (VkDeviceSize -> VkDeviceSize -> Bool)
-> (VkDeviceSize -> VkDeviceSize -> Bool)
-> (VkDeviceSize -> VkDeviceSize -> Bool)
-> (VkDeviceSize -> VkDeviceSize -> Bool)
-> (VkDeviceSize -> VkDeviceSize -> VkDeviceSize)
-> (VkDeviceSize -> VkDeviceSize -> VkDeviceSize)
-> Ord VkDeviceSize
VkDeviceSize -> VkDeviceSize -> Bool
VkDeviceSize -> VkDeviceSize -> Ordering
VkDeviceSize -> VkDeviceSize -> VkDeviceSize
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 :: VkDeviceSize -> VkDeviceSize -> VkDeviceSize
$cmin :: VkDeviceSize -> VkDeviceSize -> VkDeviceSize
max :: VkDeviceSize -> VkDeviceSize -> VkDeviceSize
$cmax :: VkDeviceSize -> VkDeviceSize -> VkDeviceSize
>= :: VkDeviceSize -> VkDeviceSize -> Bool
$c>= :: VkDeviceSize -> VkDeviceSize -> Bool
> :: VkDeviceSize -> VkDeviceSize -> Bool
$c> :: VkDeviceSize -> VkDeviceSize -> Bool
<= :: VkDeviceSize -> VkDeviceSize -> Bool
$c<= :: VkDeviceSize -> VkDeviceSize -> Bool
< :: VkDeviceSize -> VkDeviceSize -> Bool
$c< :: VkDeviceSize -> VkDeviceSize -> Bool
compare :: VkDeviceSize -> VkDeviceSize -> Ordering
$ccompare :: VkDeviceSize -> VkDeviceSize -> Ordering
Ord, Integer -> VkDeviceSize
VkDeviceSize -> VkDeviceSize
VkDeviceSize -> VkDeviceSize -> VkDeviceSize
(VkDeviceSize -> VkDeviceSize -> VkDeviceSize)
-> (VkDeviceSize -> VkDeviceSize -> VkDeviceSize)
-> (VkDeviceSize -> VkDeviceSize -> VkDeviceSize)
-> (VkDeviceSize -> VkDeviceSize)
-> (VkDeviceSize -> VkDeviceSize)
-> (VkDeviceSize -> VkDeviceSize)
-> (Integer -> VkDeviceSize)
-> Num VkDeviceSize
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
fromInteger :: Integer -> VkDeviceSize
$cfromInteger :: Integer -> VkDeviceSize
signum :: VkDeviceSize -> VkDeviceSize
$csignum :: VkDeviceSize -> VkDeviceSize
abs :: VkDeviceSize -> VkDeviceSize
$cabs :: VkDeviceSize -> VkDeviceSize
negate :: VkDeviceSize -> VkDeviceSize
$cnegate :: VkDeviceSize -> VkDeviceSize
* :: VkDeviceSize -> VkDeviceSize -> VkDeviceSize
$c* :: VkDeviceSize -> VkDeviceSize -> VkDeviceSize
- :: VkDeviceSize -> VkDeviceSize -> VkDeviceSize
$c- :: VkDeviceSize -> VkDeviceSize -> VkDeviceSize
+ :: VkDeviceSize -> VkDeviceSize -> VkDeviceSize
$c+ :: VkDeviceSize -> VkDeviceSize -> VkDeviceSize
Num, VkDeviceSize
VkDeviceSize -> VkDeviceSize -> Bounded VkDeviceSize
forall a. a -> a -> Bounded a
maxBound :: VkDeviceSize
$cmaxBound :: VkDeviceSize
minBound :: VkDeviceSize
$cminBound :: VkDeviceSize
Bounded, Int -> VkDeviceSize
VkDeviceSize -> Int
VkDeviceSize -> [VkDeviceSize]
VkDeviceSize -> VkDeviceSize
VkDeviceSize -> VkDeviceSize -> [VkDeviceSize]
VkDeviceSize -> VkDeviceSize -> VkDeviceSize -> [VkDeviceSize]
(VkDeviceSize -> VkDeviceSize)
-> (VkDeviceSize -> VkDeviceSize)
-> (Int -> VkDeviceSize)
-> (VkDeviceSize -> Int)
-> (VkDeviceSize -> [VkDeviceSize])
-> (VkDeviceSize -> VkDeviceSize -> [VkDeviceSize])
-> (VkDeviceSize -> VkDeviceSize -> [VkDeviceSize])
-> (VkDeviceSize -> VkDeviceSize -> VkDeviceSize -> [VkDeviceSize])
-> Enum VkDeviceSize
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 :: VkDeviceSize -> VkDeviceSize -> VkDeviceSize -> [VkDeviceSize]
$cenumFromThenTo :: VkDeviceSize -> VkDeviceSize -> VkDeviceSize -> [VkDeviceSize]
enumFromTo :: VkDeviceSize -> VkDeviceSize -> [VkDeviceSize]
$cenumFromTo :: VkDeviceSize -> VkDeviceSize -> [VkDeviceSize]
enumFromThen :: VkDeviceSize -> VkDeviceSize -> [VkDeviceSize]
$cenumFromThen :: VkDeviceSize -> VkDeviceSize -> [VkDeviceSize]
enumFrom :: VkDeviceSize -> [VkDeviceSize]
$cenumFrom :: VkDeviceSize -> [VkDeviceSize]
fromEnum :: VkDeviceSize -> Int
$cfromEnum :: VkDeviceSize -> Int
toEnum :: Int -> VkDeviceSize
$ctoEnum :: Int -> VkDeviceSize
pred :: VkDeviceSize -> VkDeviceSize
$cpred :: VkDeviceSize -> VkDeviceSize
succ :: VkDeviceSize -> VkDeviceSize
$csucc :: VkDeviceSize -> VkDeviceSize
Enum, Enum VkDeviceSize
Real VkDeviceSize
Real VkDeviceSize
-> Enum VkDeviceSize
-> (VkDeviceSize -> VkDeviceSize -> VkDeviceSize)
-> (VkDeviceSize -> VkDeviceSize -> VkDeviceSize)
-> (VkDeviceSize -> VkDeviceSize -> VkDeviceSize)
-> (VkDeviceSize -> VkDeviceSize -> VkDeviceSize)
-> (VkDeviceSize -> VkDeviceSize -> (VkDeviceSize, VkDeviceSize))
-> (VkDeviceSize -> VkDeviceSize -> (VkDeviceSize, VkDeviceSize))
-> (VkDeviceSize -> Integer)
-> Integral VkDeviceSize
VkDeviceSize -> Integer
VkDeviceSize -> VkDeviceSize -> (VkDeviceSize, VkDeviceSize)
VkDeviceSize -> VkDeviceSize -> VkDeviceSize
forall a.
Real a
-> Enum a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> (a, a))
-> (a -> a -> (a, a))
-> (a -> Integer)
-> Integral a
toInteger :: VkDeviceSize -> Integer
$ctoInteger :: VkDeviceSize -> Integer
divMod :: VkDeviceSize -> VkDeviceSize -> (VkDeviceSize, VkDeviceSize)
$cdivMod :: VkDeviceSize -> VkDeviceSize -> (VkDeviceSize, VkDeviceSize)
quotRem :: VkDeviceSize -> VkDeviceSize -> (VkDeviceSize, VkDeviceSize)
$cquotRem :: VkDeviceSize -> VkDeviceSize -> (VkDeviceSize, VkDeviceSize)
mod :: VkDeviceSize -> VkDeviceSize -> VkDeviceSize
$cmod :: VkDeviceSize -> VkDeviceSize -> VkDeviceSize
div :: VkDeviceSize -> VkDeviceSize -> VkDeviceSize
$cdiv :: VkDeviceSize -> VkDeviceSize -> VkDeviceSize
rem :: VkDeviceSize -> VkDeviceSize -> VkDeviceSize
$crem :: VkDeviceSize -> VkDeviceSize -> VkDeviceSize
quot :: VkDeviceSize -> VkDeviceSize -> VkDeviceSize
$cquot :: VkDeviceSize -> VkDeviceSize -> VkDeviceSize
Integral, Num VkDeviceSize
Ord VkDeviceSize
Num VkDeviceSize
-> Ord VkDeviceSize
-> (VkDeviceSize -> Rational)
-> Real VkDeviceSize
VkDeviceSize -> Rational
forall a. Num a -> Ord a -> (a -> Rational) -> Real a
toRational :: VkDeviceSize -> Rational
$ctoRational :: VkDeviceSize -> Rational
Real, Eq VkDeviceSize
VkDeviceSize
Eq VkDeviceSize
-> (VkDeviceSize -> VkDeviceSize -> VkDeviceSize)
-> (VkDeviceSize -> VkDeviceSize -> VkDeviceSize)
-> (VkDeviceSize -> VkDeviceSize -> VkDeviceSize)
-> (VkDeviceSize -> VkDeviceSize)
-> (VkDeviceSize -> Int -> VkDeviceSize)
-> (VkDeviceSize -> Int -> VkDeviceSize)
-> VkDeviceSize
-> (Int -> VkDeviceSize)
-> (VkDeviceSize -> Int -> VkDeviceSize)
-> (VkDeviceSize -> Int -> VkDeviceSize)
-> (VkDeviceSize -> Int -> VkDeviceSize)
-> (VkDeviceSize -> Int -> Bool)
-> (VkDeviceSize -> Maybe Int)
-> (VkDeviceSize -> Int)
-> (VkDeviceSize -> Bool)
-> (VkDeviceSize -> Int -> VkDeviceSize)
-> (VkDeviceSize -> Int -> VkDeviceSize)
-> (VkDeviceSize -> Int -> VkDeviceSize)
-> (VkDeviceSize -> Int -> VkDeviceSize)
-> (VkDeviceSize -> Int -> VkDeviceSize)
-> (VkDeviceSize -> Int -> VkDeviceSize)
-> (VkDeviceSize -> Int)
-> Bits VkDeviceSize
Int -> VkDeviceSize
VkDeviceSize -> Bool
VkDeviceSize -> Int
VkDeviceSize -> Maybe Int
VkDeviceSize -> VkDeviceSize
VkDeviceSize -> Int -> Bool
VkDeviceSize -> Int -> VkDeviceSize
VkDeviceSize -> VkDeviceSize -> VkDeviceSize
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 :: VkDeviceSize -> Int
$cpopCount :: VkDeviceSize -> Int
rotateR :: VkDeviceSize -> Int -> VkDeviceSize
$crotateR :: VkDeviceSize -> Int -> VkDeviceSize
rotateL :: VkDeviceSize -> Int -> VkDeviceSize
$crotateL :: VkDeviceSize -> Int -> VkDeviceSize
unsafeShiftR :: VkDeviceSize -> Int -> VkDeviceSize
$cunsafeShiftR :: VkDeviceSize -> Int -> VkDeviceSize
shiftR :: VkDeviceSize -> Int -> VkDeviceSize
$cshiftR :: VkDeviceSize -> Int -> VkDeviceSize
unsafeShiftL :: VkDeviceSize -> Int -> VkDeviceSize
$cunsafeShiftL :: VkDeviceSize -> Int -> VkDeviceSize
shiftL :: VkDeviceSize -> Int -> VkDeviceSize
$cshiftL :: VkDeviceSize -> Int -> VkDeviceSize
isSigned :: VkDeviceSize -> Bool
$cisSigned :: VkDeviceSize -> Bool
bitSize :: VkDeviceSize -> Int
$cbitSize :: VkDeviceSize -> Int
bitSizeMaybe :: VkDeviceSize -> Maybe Int
$cbitSizeMaybe :: VkDeviceSize -> Maybe Int
testBit :: VkDeviceSize -> Int -> Bool
$ctestBit :: VkDeviceSize -> Int -> Bool
complementBit :: VkDeviceSize -> Int -> VkDeviceSize
$ccomplementBit :: VkDeviceSize -> Int -> VkDeviceSize
clearBit :: VkDeviceSize -> Int -> VkDeviceSize
$cclearBit :: VkDeviceSize -> Int -> VkDeviceSize
setBit :: VkDeviceSize -> Int -> VkDeviceSize
$csetBit :: VkDeviceSize -> Int -> VkDeviceSize
bit :: Int -> VkDeviceSize
$cbit :: Int -> VkDeviceSize
zeroBits :: VkDeviceSize
$czeroBits :: VkDeviceSize
rotate :: VkDeviceSize -> Int -> VkDeviceSize
$crotate :: VkDeviceSize -> Int -> VkDeviceSize
shift :: VkDeviceSize -> Int -> VkDeviceSize
$cshift :: VkDeviceSize -> Int -> VkDeviceSize
complement :: VkDeviceSize -> VkDeviceSize
$ccomplement :: VkDeviceSize -> VkDeviceSize
xor :: VkDeviceSize -> VkDeviceSize -> VkDeviceSize
$cxor :: VkDeviceSize -> VkDeviceSize -> VkDeviceSize
.|. :: VkDeviceSize -> VkDeviceSize -> VkDeviceSize
$c.|. :: VkDeviceSize -> VkDeviceSize -> VkDeviceSize
.&. :: VkDeviceSize -> VkDeviceSize -> VkDeviceSize
$c.&. :: VkDeviceSize -> VkDeviceSize -> VkDeviceSize
Bits,
                                 Bits VkDeviceSize
Bits VkDeviceSize
-> (VkDeviceSize -> Int)
-> (VkDeviceSize -> Int)
-> (VkDeviceSize -> Int)
-> FiniteBits VkDeviceSize
VkDeviceSize -> Int
forall b.
Bits b -> (b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
countTrailingZeros :: VkDeviceSize -> Int
$ccountTrailingZeros :: VkDeviceSize -> Int
countLeadingZeros :: VkDeviceSize -> Int
$ccountLeadingZeros :: VkDeviceSize -> Int
finiteBitSize :: VkDeviceSize -> Int
$cfiniteBitSize :: VkDeviceSize -> Int
FiniteBits, Ptr VkDeviceSize -> IO VkDeviceSize
Ptr VkDeviceSize -> Int -> IO VkDeviceSize
Ptr VkDeviceSize -> Int -> VkDeviceSize -> IO ()
Ptr VkDeviceSize -> VkDeviceSize -> IO ()
VkDeviceSize -> Int
(VkDeviceSize -> Int)
-> (VkDeviceSize -> Int)
-> (Ptr VkDeviceSize -> Int -> IO VkDeviceSize)
-> (Ptr VkDeviceSize -> Int -> VkDeviceSize -> IO ())
-> (forall b. Ptr b -> Int -> IO VkDeviceSize)
-> (forall b. Ptr b -> Int -> VkDeviceSize -> IO ())
-> (Ptr VkDeviceSize -> IO VkDeviceSize)
-> (Ptr VkDeviceSize -> VkDeviceSize -> IO ())
-> Storable VkDeviceSize
forall b. Ptr b -> Int -> IO VkDeviceSize
forall b. Ptr b -> Int -> VkDeviceSize -> 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 VkDeviceSize -> VkDeviceSize -> IO ()
$cpoke :: Ptr VkDeviceSize -> VkDeviceSize -> IO ()
peek :: Ptr VkDeviceSize -> IO VkDeviceSize
$cpeek :: Ptr VkDeviceSize -> IO VkDeviceSize
pokeByteOff :: forall b. Ptr b -> Int -> VkDeviceSize -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> VkDeviceSize -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO VkDeviceSize
$cpeekByteOff :: forall b. Ptr b -> Int -> IO VkDeviceSize
pokeElemOff :: Ptr VkDeviceSize -> Int -> VkDeviceSize -> IO ()
$cpokeElemOff :: Ptr VkDeviceSize -> Int -> VkDeviceSize -> IO ()
peekElemOff :: Ptr VkDeviceSize -> Int -> IO VkDeviceSize
$cpeekElemOff :: Ptr VkDeviceSize -> Int -> IO VkDeviceSize
alignment :: VkDeviceSize -> Int
$calignment :: VkDeviceSize -> Int
sizeOf :: VkDeviceSize -> Int
$csizeOf :: VkDeviceSize -> Int
Storable)

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

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

newtype VkFlags = VkFlags Word32
                  deriving (VkFlags -> VkFlags -> Bool
(VkFlags -> VkFlags -> Bool)
-> (VkFlags -> VkFlags -> Bool) -> Eq VkFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VkFlags -> VkFlags -> Bool
$c/= :: VkFlags -> VkFlags -> Bool
== :: VkFlags -> VkFlags -> Bool
$c== :: VkFlags -> VkFlags -> Bool
Eq, Eq VkFlags
Eq VkFlags
-> (VkFlags -> VkFlags -> Ordering)
-> (VkFlags -> VkFlags -> Bool)
-> (VkFlags -> VkFlags -> Bool)
-> (VkFlags -> VkFlags -> Bool)
-> (VkFlags -> VkFlags -> Bool)
-> (VkFlags -> VkFlags -> VkFlags)
-> (VkFlags -> VkFlags -> VkFlags)
-> Ord VkFlags
VkFlags -> VkFlags -> Bool
VkFlags -> VkFlags -> Ordering
VkFlags -> VkFlags -> VkFlags
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 :: VkFlags -> VkFlags -> VkFlags
$cmin :: VkFlags -> VkFlags -> VkFlags
max :: VkFlags -> VkFlags -> VkFlags
$cmax :: VkFlags -> VkFlags -> VkFlags
>= :: VkFlags -> VkFlags -> Bool
$c>= :: VkFlags -> VkFlags -> Bool
> :: VkFlags -> VkFlags -> Bool
$c> :: VkFlags -> VkFlags -> Bool
<= :: VkFlags -> VkFlags -> Bool
$c<= :: VkFlags -> VkFlags -> Bool
< :: VkFlags -> VkFlags -> Bool
$c< :: VkFlags -> VkFlags -> Bool
compare :: VkFlags -> VkFlags -> Ordering
$ccompare :: VkFlags -> VkFlags -> Ordering
Ord, Integer -> VkFlags
VkFlags -> VkFlags
VkFlags -> VkFlags -> VkFlags
(VkFlags -> VkFlags -> VkFlags)
-> (VkFlags -> VkFlags -> VkFlags)
-> (VkFlags -> VkFlags -> VkFlags)
-> (VkFlags -> VkFlags)
-> (VkFlags -> VkFlags)
-> (VkFlags -> VkFlags)
-> (Integer -> VkFlags)
-> Num VkFlags
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
fromInteger :: Integer -> VkFlags
$cfromInteger :: Integer -> VkFlags
signum :: VkFlags -> VkFlags
$csignum :: VkFlags -> VkFlags
abs :: VkFlags -> VkFlags
$cabs :: VkFlags -> VkFlags
negate :: VkFlags -> VkFlags
$cnegate :: VkFlags -> VkFlags
* :: VkFlags -> VkFlags -> VkFlags
$c* :: VkFlags -> VkFlags -> VkFlags
- :: VkFlags -> VkFlags -> VkFlags
$c- :: VkFlags -> VkFlags -> VkFlags
+ :: VkFlags -> VkFlags -> VkFlags
$c+ :: VkFlags -> VkFlags -> VkFlags
Num, VkFlags
VkFlags -> VkFlags -> Bounded VkFlags
forall a. a -> a -> Bounded a
maxBound :: VkFlags
$cmaxBound :: VkFlags
minBound :: VkFlags
$cminBound :: VkFlags
Bounded, Int -> VkFlags
VkFlags -> Int
VkFlags -> [VkFlags]
VkFlags -> VkFlags
VkFlags -> VkFlags -> [VkFlags]
VkFlags -> VkFlags -> VkFlags -> [VkFlags]
(VkFlags -> VkFlags)
-> (VkFlags -> VkFlags)
-> (Int -> VkFlags)
-> (VkFlags -> Int)
-> (VkFlags -> [VkFlags])
-> (VkFlags -> VkFlags -> [VkFlags])
-> (VkFlags -> VkFlags -> [VkFlags])
-> (VkFlags -> VkFlags -> VkFlags -> [VkFlags])
-> Enum VkFlags
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 :: VkFlags -> VkFlags -> VkFlags -> [VkFlags]
$cenumFromThenTo :: VkFlags -> VkFlags -> VkFlags -> [VkFlags]
enumFromTo :: VkFlags -> VkFlags -> [VkFlags]
$cenumFromTo :: VkFlags -> VkFlags -> [VkFlags]
enumFromThen :: VkFlags -> VkFlags -> [VkFlags]
$cenumFromThen :: VkFlags -> VkFlags -> [VkFlags]
enumFrom :: VkFlags -> [VkFlags]
$cenumFrom :: VkFlags -> [VkFlags]
fromEnum :: VkFlags -> Int
$cfromEnum :: VkFlags -> Int
toEnum :: Int -> VkFlags
$ctoEnum :: Int -> VkFlags
pred :: VkFlags -> VkFlags
$cpred :: VkFlags -> VkFlags
succ :: VkFlags -> VkFlags
$csucc :: VkFlags -> VkFlags
Enum, Enum VkFlags
Real VkFlags
Real VkFlags
-> Enum VkFlags
-> (VkFlags -> VkFlags -> VkFlags)
-> (VkFlags -> VkFlags -> VkFlags)
-> (VkFlags -> VkFlags -> VkFlags)
-> (VkFlags -> VkFlags -> VkFlags)
-> (VkFlags -> VkFlags -> (VkFlags, VkFlags))
-> (VkFlags -> VkFlags -> (VkFlags, VkFlags))
-> (VkFlags -> Integer)
-> Integral VkFlags
VkFlags -> Integer
VkFlags -> VkFlags -> (VkFlags, VkFlags)
VkFlags -> VkFlags -> VkFlags
forall a.
Real a
-> Enum a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> (a, a))
-> (a -> a -> (a, a))
-> (a -> Integer)
-> Integral a
toInteger :: VkFlags -> Integer
$ctoInteger :: VkFlags -> Integer
divMod :: VkFlags -> VkFlags -> (VkFlags, VkFlags)
$cdivMod :: VkFlags -> VkFlags -> (VkFlags, VkFlags)
quotRem :: VkFlags -> VkFlags -> (VkFlags, VkFlags)
$cquotRem :: VkFlags -> VkFlags -> (VkFlags, VkFlags)
mod :: VkFlags -> VkFlags -> VkFlags
$cmod :: VkFlags -> VkFlags -> VkFlags
div :: VkFlags -> VkFlags -> VkFlags
$cdiv :: VkFlags -> VkFlags -> VkFlags
rem :: VkFlags -> VkFlags -> VkFlags
$crem :: VkFlags -> VkFlags -> VkFlags
quot :: VkFlags -> VkFlags -> VkFlags
$cquot :: VkFlags -> VkFlags -> VkFlags
Integral, Num VkFlags
Ord VkFlags
Num VkFlags -> Ord VkFlags -> (VkFlags -> Rational) -> Real VkFlags
VkFlags -> Rational
forall a. Num a -> Ord a -> (a -> Rational) -> Real a
toRational :: VkFlags -> Rational
$ctoRational :: VkFlags -> Rational
Real, Eq VkFlags
VkFlags
Eq VkFlags
-> (VkFlags -> VkFlags -> VkFlags)
-> (VkFlags -> VkFlags -> VkFlags)
-> (VkFlags -> VkFlags -> VkFlags)
-> (VkFlags -> VkFlags)
-> (VkFlags -> Int -> VkFlags)
-> (VkFlags -> Int -> VkFlags)
-> VkFlags
-> (Int -> VkFlags)
-> (VkFlags -> Int -> VkFlags)
-> (VkFlags -> Int -> VkFlags)
-> (VkFlags -> Int -> VkFlags)
-> (VkFlags -> Int -> Bool)
-> (VkFlags -> Maybe Int)
-> (VkFlags -> Int)
-> (VkFlags -> Bool)
-> (VkFlags -> Int -> VkFlags)
-> (VkFlags -> Int -> VkFlags)
-> (VkFlags -> Int -> VkFlags)
-> (VkFlags -> Int -> VkFlags)
-> (VkFlags -> Int -> VkFlags)
-> (VkFlags -> Int -> VkFlags)
-> (VkFlags -> Int)
-> Bits VkFlags
Int -> VkFlags
VkFlags -> Bool
VkFlags -> Int
VkFlags -> Maybe Int
VkFlags -> VkFlags
VkFlags -> Int -> Bool
VkFlags -> Int -> VkFlags
VkFlags -> VkFlags -> VkFlags
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 :: VkFlags -> Int
$cpopCount :: VkFlags -> Int
rotateR :: VkFlags -> Int -> VkFlags
$crotateR :: VkFlags -> Int -> VkFlags
rotateL :: VkFlags -> Int -> VkFlags
$crotateL :: VkFlags -> Int -> VkFlags
unsafeShiftR :: VkFlags -> Int -> VkFlags
$cunsafeShiftR :: VkFlags -> Int -> VkFlags
shiftR :: VkFlags -> Int -> VkFlags
$cshiftR :: VkFlags -> Int -> VkFlags
unsafeShiftL :: VkFlags -> Int -> VkFlags
$cunsafeShiftL :: VkFlags -> Int -> VkFlags
shiftL :: VkFlags -> Int -> VkFlags
$cshiftL :: VkFlags -> Int -> VkFlags
isSigned :: VkFlags -> Bool
$cisSigned :: VkFlags -> Bool
bitSize :: VkFlags -> Int
$cbitSize :: VkFlags -> Int
bitSizeMaybe :: VkFlags -> Maybe Int
$cbitSizeMaybe :: VkFlags -> Maybe Int
testBit :: VkFlags -> Int -> Bool
$ctestBit :: VkFlags -> Int -> Bool
complementBit :: VkFlags -> Int -> VkFlags
$ccomplementBit :: VkFlags -> Int -> VkFlags
clearBit :: VkFlags -> Int -> VkFlags
$cclearBit :: VkFlags -> Int -> VkFlags
setBit :: VkFlags -> Int -> VkFlags
$csetBit :: VkFlags -> Int -> VkFlags
bit :: Int -> VkFlags
$cbit :: Int -> VkFlags
zeroBits :: VkFlags
$czeroBits :: VkFlags
rotate :: VkFlags -> Int -> VkFlags
$crotate :: VkFlags -> Int -> VkFlags
shift :: VkFlags -> Int -> VkFlags
$cshift :: VkFlags -> Int -> VkFlags
complement :: VkFlags -> VkFlags
$ccomplement :: VkFlags -> VkFlags
xor :: VkFlags -> VkFlags -> VkFlags
$cxor :: VkFlags -> VkFlags -> VkFlags
.|. :: VkFlags -> VkFlags -> VkFlags
$c.|. :: VkFlags -> VkFlags -> VkFlags
.&. :: VkFlags -> VkFlags -> VkFlags
$c.&. :: VkFlags -> VkFlags -> VkFlags
Bits,
                            Bits VkFlags
Bits VkFlags
-> (VkFlags -> Int)
-> (VkFlags -> Int)
-> (VkFlags -> Int)
-> FiniteBits VkFlags
VkFlags -> Int
forall b.
Bits b -> (b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
countTrailingZeros :: VkFlags -> Int
$ccountTrailingZeros :: VkFlags -> Int
countLeadingZeros :: VkFlags -> Int
$ccountLeadingZeros :: VkFlags -> Int
finiteBitSize :: VkFlags -> Int
$cfiniteBitSize :: VkFlags -> Int
FiniteBits, Ptr VkFlags -> IO VkFlags
Ptr VkFlags -> Int -> IO VkFlags
Ptr VkFlags -> Int -> VkFlags -> IO ()
Ptr VkFlags -> VkFlags -> IO ()
VkFlags -> Int
(VkFlags -> Int)
-> (VkFlags -> Int)
-> (Ptr VkFlags -> Int -> IO VkFlags)
-> (Ptr VkFlags -> Int -> VkFlags -> IO ())
-> (forall b. Ptr b -> Int -> IO VkFlags)
-> (forall b. Ptr b -> Int -> VkFlags -> IO ())
-> (Ptr VkFlags -> IO VkFlags)
-> (Ptr VkFlags -> VkFlags -> IO ())
-> Storable VkFlags
forall b. Ptr b -> Int -> IO VkFlags
forall b. Ptr b -> Int -> VkFlags -> 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 VkFlags -> VkFlags -> IO ()
$cpoke :: Ptr VkFlags -> VkFlags -> IO ()
peek :: Ptr VkFlags -> IO VkFlags
$cpeek :: Ptr VkFlags -> IO VkFlags
pokeByteOff :: forall b. Ptr b -> Int -> VkFlags -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> VkFlags -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO VkFlags
$cpeekByteOff :: forall b. Ptr b -> Int -> IO VkFlags
pokeElemOff :: Ptr VkFlags -> Int -> VkFlags -> IO ()
$cpokeElemOff :: Ptr VkFlags -> Int -> VkFlags -> IO ()
peekElemOff :: Ptr VkFlags -> Int -> IO VkFlags
$cpeekElemOff :: Ptr VkFlags -> Int -> IO VkFlags
alignment :: VkFlags -> Int
$calignment :: VkFlags -> Int
sizeOf :: VkFlags -> Int
$csizeOf :: VkFlags -> Int
Storable)

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

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

newtype VkSampleMask = VkSampleMask Word32
                       deriving (VkSampleMask -> VkSampleMask -> Bool
(VkSampleMask -> VkSampleMask -> Bool)
-> (VkSampleMask -> VkSampleMask -> Bool) -> Eq VkSampleMask
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VkSampleMask -> VkSampleMask -> Bool
$c/= :: VkSampleMask -> VkSampleMask -> Bool
== :: VkSampleMask -> VkSampleMask -> Bool
$c== :: VkSampleMask -> VkSampleMask -> Bool
Eq, Eq VkSampleMask
Eq VkSampleMask
-> (VkSampleMask -> VkSampleMask -> Ordering)
-> (VkSampleMask -> VkSampleMask -> Bool)
-> (VkSampleMask -> VkSampleMask -> Bool)
-> (VkSampleMask -> VkSampleMask -> Bool)
-> (VkSampleMask -> VkSampleMask -> Bool)
-> (VkSampleMask -> VkSampleMask -> VkSampleMask)
-> (VkSampleMask -> VkSampleMask -> VkSampleMask)
-> Ord VkSampleMask
VkSampleMask -> VkSampleMask -> Bool
VkSampleMask -> VkSampleMask -> Ordering
VkSampleMask -> VkSampleMask -> VkSampleMask
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 :: VkSampleMask -> VkSampleMask -> VkSampleMask
$cmin :: VkSampleMask -> VkSampleMask -> VkSampleMask
max :: VkSampleMask -> VkSampleMask -> VkSampleMask
$cmax :: VkSampleMask -> VkSampleMask -> VkSampleMask
>= :: VkSampleMask -> VkSampleMask -> Bool
$c>= :: VkSampleMask -> VkSampleMask -> Bool
> :: VkSampleMask -> VkSampleMask -> Bool
$c> :: VkSampleMask -> VkSampleMask -> Bool
<= :: VkSampleMask -> VkSampleMask -> Bool
$c<= :: VkSampleMask -> VkSampleMask -> Bool
< :: VkSampleMask -> VkSampleMask -> Bool
$c< :: VkSampleMask -> VkSampleMask -> Bool
compare :: VkSampleMask -> VkSampleMask -> Ordering
$ccompare :: VkSampleMask -> VkSampleMask -> Ordering
Ord, Integer -> VkSampleMask
VkSampleMask -> VkSampleMask
VkSampleMask -> VkSampleMask -> VkSampleMask
(VkSampleMask -> VkSampleMask -> VkSampleMask)
-> (VkSampleMask -> VkSampleMask -> VkSampleMask)
-> (VkSampleMask -> VkSampleMask -> VkSampleMask)
-> (VkSampleMask -> VkSampleMask)
-> (VkSampleMask -> VkSampleMask)
-> (VkSampleMask -> VkSampleMask)
-> (Integer -> VkSampleMask)
-> Num VkSampleMask
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
fromInteger :: Integer -> VkSampleMask
$cfromInteger :: Integer -> VkSampleMask
signum :: VkSampleMask -> VkSampleMask
$csignum :: VkSampleMask -> VkSampleMask
abs :: VkSampleMask -> VkSampleMask
$cabs :: VkSampleMask -> VkSampleMask
negate :: VkSampleMask -> VkSampleMask
$cnegate :: VkSampleMask -> VkSampleMask
* :: VkSampleMask -> VkSampleMask -> VkSampleMask
$c* :: VkSampleMask -> VkSampleMask -> VkSampleMask
- :: VkSampleMask -> VkSampleMask -> VkSampleMask
$c- :: VkSampleMask -> VkSampleMask -> VkSampleMask
+ :: VkSampleMask -> VkSampleMask -> VkSampleMask
$c+ :: VkSampleMask -> VkSampleMask -> VkSampleMask
Num, VkSampleMask
VkSampleMask -> VkSampleMask -> Bounded VkSampleMask
forall a. a -> a -> Bounded a
maxBound :: VkSampleMask
$cmaxBound :: VkSampleMask
minBound :: VkSampleMask
$cminBound :: VkSampleMask
Bounded, Int -> VkSampleMask
VkSampleMask -> Int
VkSampleMask -> [VkSampleMask]
VkSampleMask -> VkSampleMask
VkSampleMask -> VkSampleMask -> [VkSampleMask]
VkSampleMask -> VkSampleMask -> VkSampleMask -> [VkSampleMask]
(VkSampleMask -> VkSampleMask)
-> (VkSampleMask -> VkSampleMask)
-> (Int -> VkSampleMask)
-> (VkSampleMask -> Int)
-> (VkSampleMask -> [VkSampleMask])
-> (VkSampleMask -> VkSampleMask -> [VkSampleMask])
-> (VkSampleMask -> VkSampleMask -> [VkSampleMask])
-> (VkSampleMask -> VkSampleMask -> VkSampleMask -> [VkSampleMask])
-> Enum VkSampleMask
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 :: VkSampleMask -> VkSampleMask -> VkSampleMask -> [VkSampleMask]
$cenumFromThenTo :: VkSampleMask -> VkSampleMask -> VkSampleMask -> [VkSampleMask]
enumFromTo :: VkSampleMask -> VkSampleMask -> [VkSampleMask]
$cenumFromTo :: VkSampleMask -> VkSampleMask -> [VkSampleMask]
enumFromThen :: VkSampleMask -> VkSampleMask -> [VkSampleMask]
$cenumFromThen :: VkSampleMask -> VkSampleMask -> [VkSampleMask]
enumFrom :: VkSampleMask -> [VkSampleMask]
$cenumFrom :: VkSampleMask -> [VkSampleMask]
fromEnum :: VkSampleMask -> Int
$cfromEnum :: VkSampleMask -> Int
toEnum :: Int -> VkSampleMask
$ctoEnum :: Int -> VkSampleMask
pred :: VkSampleMask -> VkSampleMask
$cpred :: VkSampleMask -> VkSampleMask
succ :: VkSampleMask -> VkSampleMask
$csucc :: VkSampleMask -> VkSampleMask
Enum, Enum VkSampleMask
Real VkSampleMask
Real VkSampleMask
-> Enum VkSampleMask
-> (VkSampleMask -> VkSampleMask -> VkSampleMask)
-> (VkSampleMask -> VkSampleMask -> VkSampleMask)
-> (VkSampleMask -> VkSampleMask -> VkSampleMask)
-> (VkSampleMask -> VkSampleMask -> VkSampleMask)
-> (VkSampleMask -> VkSampleMask -> (VkSampleMask, VkSampleMask))
-> (VkSampleMask -> VkSampleMask -> (VkSampleMask, VkSampleMask))
-> (VkSampleMask -> Integer)
-> Integral VkSampleMask
VkSampleMask -> Integer
VkSampleMask -> VkSampleMask -> (VkSampleMask, VkSampleMask)
VkSampleMask -> VkSampleMask -> VkSampleMask
forall a.
Real a
-> Enum a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> (a, a))
-> (a -> a -> (a, a))
-> (a -> Integer)
-> Integral a
toInteger :: VkSampleMask -> Integer
$ctoInteger :: VkSampleMask -> Integer
divMod :: VkSampleMask -> VkSampleMask -> (VkSampleMask, VkSampleMask)
$cdivMod :: VkSampleMask -> VkSampleMask -> (VkSampleMask, VkSampleMask)
quotRem :: VkSampleMask -> VkSampleMask -> (VkSampleMask, VkSampleMask)
$cquotRem :: VkSampleMask -> VkSampleMask -> (VkSampleMask, VkSampleMask)
mod :: VkSampleMask -> VkSampleMask -> VkSampleMask
$cmod :: VkSampleMask -> VkSampleMask -> VkSampleMask
div :: VkSampleMask -> VkSampleMask -> VkSampleMask
$cdiv :: VkSampleMask -> VkSampleMask -> VkSampleMask
rem :: VkSampleMask -> VkSampleMask -> VkSampleMask
$crem :: VkSampleMask -> VkSampleMask -> VkSampleMask
quot :: VkSampleMask -> VkSampleMask -> VkSampleMask
$cquot :: VkSampleMask -> VkSampleMask -> VkSampleMask
Integral, Num VkSampleMask
Ord VkSampleMask
Num VkSampleMask
-> Ord VkSampleMask
-> (VkSampleMask -> Rational)
-> Real VkSampleMask
VkSampleMask -> Rational
forall a. Num a -> Ord a -> (a -> Rational) -> Real a
toRational :: VkSampleMask -> Rational
$ctoRational :: VkSampleMask -> Rational
Real, Eq VkSampleMask
VkSampleMask
Eq VkSampleMask
-> (VkSampleMask -> VkSampleMask -> VkSampleMask)
-> (VkSampleMask -> VkSampleMask -> VkSampleMask)
-> (VkSampleMask -> VkSampleMask -> VkSampleMask)
-> (VkSampleMask -> VkSampleMask)
-> (VkSampleMask -> Int -> VkSampleMask)
-> (VkSampleMask -> Int -> VkSampleMask)
-> VkSampleMask
-> (Int -> VkSampleMask)
-> (VkSampleMask -> Int -> VkSampleMask)
-> (VkSampleMask -> Int -> VkSampleMask)
-> (VkSampleMask -> Int -> VkSampleMask)
-> (VkSampleMask -> Int -> Bool)
-> (VkSampleMask -> Maybe Int)
-> (VkSampleMask -> Int)
-> (VkSampleMask -> Bool)
-> (VkSampleMask -> Int -> VkSampleMask)
-> (VkSampleMask -> Int -> VkSampleMask)
-> (VkSampleMask -> Int -> VkSampleMask)
-> (VkSampleMask -> Int -> VkSampleMask)
-> (VkSampleMask -> Int -> VkSampleMask)
-> (VkSampleMask -> Int -> VkSampleMask)
-> (VkSampleMask -> Int)
-> Bits VkSampleMask
Int -> VkSampleMask
VkSampleMask -> Bool
VkSampleMask -> Int
VkSampleMask -> Maybe Int
VkSampleMask -> VkSampleMask
VkSampleMask -> Int -> Bool
VkSampleMask -> Int -> VkSampleMask
VkSampleMask -> VkSampleMask -> VkSampleMask
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 :: VkSampleMask -> Int
$cpopCount :: VkSampleMask -> Int
rotateR :: VkSampleMask -> Int -> VkSampleMask
$crotateR :: VkSampleMask -> Int -> VkSampleMask
rotateL :: VkSampleMask -> Int -> VkSampleMask
$crotateL :: VkSampleMask -> Int -> VkSampleMask
unsafeShiftR :: VkSampleMask -> Int -> VkSampleMask
$cunsafeShiftR :: VkSampleMask -> Int -> VkSampleMask
shiftR :: VkSampleMask -> Int -> VkSampleMask
$cshiftR :: VkSampleMask -> Int -> VkSampleMask
unsafeShiftL :: VkSampleMask -> Int -> VkSampleMask
$cunsafeShiftL :: VkSampleMask -> Int -> VkSampleMask
shiftL :: VkSampleMask -> Int -> VkSampleMask
$cshiftL :: VkSampleMask -> Int -> VkSampleMask
isSigned :: VkSampleMask -> Bool
$cisSigned :: VkSampleMask -> Bool
bitSize :: VkSampleMask -> Int
$cbitSize :: VkSampleMask -> Int
bitSizeMaybe :: VkSampleMask -> Maybe Int
$cbitSizeMaybe :: VkSampleMask -> Maybe Int
testBit :: VkSampleMask -> Int -> Bool
$ctestBit :: VkSampleMask -> Int -> Bool
complementBit :: VkSampleMask -> Int -> VkSampleMask
$ccomplementBit :: VkSampleMask -> Int -> VkSampleMask
clearBit :: VkSampleMask -> Int -> VkSampleMask
$cclearBit :: VkSampleMask -> Int -> VkSampleMask
setBit :: VkSampleMask -> Int -> VkSampleMask
$csetBit :: VkSampleMask -> Int -> VkSampleMask
bit :: Int -> VkSampleMask
$cbit :: Int -> VkSampleMask
zeroBits :: VkSampleMask
$czeroBits :: VkSampleMask
rotate :: VkSampleMask -> Int -> VkSampleMask
$crotate :: VkSampleMask -> Int -> VkSampleMask
shift :: VkSampleMask -> Int -> VkSampleMask
$cshift :: VkSampleMask -> Int -> VkSampleMask
complement :: VkSampleMask -> VkSampleMask
$ccomplement :: VkSampleMask -> VkSampleMask
xor :: VkSampleMask -> VkSampleMask -> VkSampleMask
$cxor :: VkSampleMask -> VkSampleMask -> VkSampleMask
.|. :: VkSampleMask -> VkSampleMask -> VkSampleMask
$c.|. :: VkSampleMask -> VkSampleMask -> VkSampleMask
.&. :: VkSampleMask -> VkSampleMask -> VkSampleMask
$c.&. :: VkSampleMask -> VkSampleMask -> VkSampleMask
Bits,
                                 Bits VkSampleMask
Bits VkSampleMask
-> (VkSampleMask -> Int)
-> (VkSampleMask -> Int)
-> (VkSampleMask -> Int)
-> FiniteBits VkSampleMask
VkSampleMask -> Int
forall b.
Bits b -> (b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
countTrailingZeros :: VkSampleMask -> Int
$ccountTrailingZeros :: VkSampleMask -> Int
countLeadingZeros :: VkSampleMask -> Int
$ccountLeadingZeros :: VkSampleMask -> Int
finiteBitSize :: VkSampleMask -> Int
$cfiniteBitSize :: VkSampleMask -> Int
FiniteBits, Ptr VkSampleMask -> IO VkSampleMask
Ptr VkSampleMask -> Int -> IO VkSampleMask
Ptr VkSampleMask -> Int -> VkSampleMask -> IO ()
Ptr VkSampleMask -> VkSampleMask -> IO ()
VkSampleMask -> Int
(VkSampleMask -> Int)
-> (VkSampleMask -> Int)
-> (Ptr VkSampleMask -> Int -> IO VkSampleMask)
-> (Ptr VkSampleMask -> Int -> VkSampleMask -> IO ())
-> (forall b. Ptr b -> Int -> IO VkSampleMask)
-> (forall b. Ptr b -> Int -> VkSampleMask -> IO ())
-> (Ptr VkSampleMask -> IO VkSampleMask)
-> (Ptr VkSampleMask -> VkSampleMask -> IO ())
-> Storable VkSampleMask
forall b. Ptr b -> Int -> IO VkSampleMask
forall b. Ptr b -> Int -> VkSampleMask -> 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 VkSampleMask -> VkSampleMask -> IO ()
$cpoke :: Ptr VkSampleMask -> VkSampleMask -> IO ()
peek :: Ptr VkSampleMask -> IO VkSampleMask
$cpeek :: Ptr VkSampleMask -> IO VkSampleMask
pokeByteOff :: forall b. Ptr b -> Int -> VkSampleMask -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> VkSampleMask -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO VkSampleMask
$cpeekByteOff :: forall b. Ptr b -> Int -> IO VkSampleMask
pokeElemOff :: Ptr VkSampleMask -> Int -> VkSampleMask -> IO ()
$cpokeElemOff :: Ptr VkSampleMask -> Int -> VkSampleMask -> IO ()
peekElemOff :: Ptr VkSampleMask -> Int -> IO VkSampleMask
$cpeekElemOff :: Ptr VkSampleMask -> Int -> IO VkSampleMask
alignment :: VkSampleMask -> Int
$calignment :: VkSampleMask -> Int
sizeOf :: VkSampleMask -> Int
$csizeOf :: VkSampleMask -> Int
Storable)

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

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