module Data.SpirV.Enum.RayFlags where

import Data.Bits (Bits)
import Data.String (IsString(..))
import Data.Word (Word32)
import Foreign (Storable(..))
import GHC.Read (Read(..))
import Text.ParserCombinators.ReadPrec (pfail)
import qualified GHC.Read as Read
import qualified Text.Read.Lex as Lex

newtype RayFlags = RayFlags Word32
  deriving (RayFlags -> RayFlags -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RayFlags -> RayFlags -> Bool
$c/= :: RayFlags -> RayFlags -> Bool
== :: RayFlags -> RayFlags -> Bool
$c== :: RayFlags -> RayFlags -> Bool
Eq, Eq RayFlags
RayFlags -> RayFlags -> Bool
RayFlags -> RayFlags -> Ordering
RayFlags -> RayFlags -> RayFlags
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 :: RayFlags -> RayFlags -> RayFlags
$cmin :: RayFlags -> RayFlags -> RayFlags
max :: RayFlags -> RayFlags -> RayFlags
$cmax :: RayFlags -> RayFlags -> RayFlags
>= :: RayFlags -> RayFlags -> Bool
$c>= :: RayFlags -> RayFlags -> Bool
> :: RayFlags -> RayFlags -> Bool
$c> :: RayFlags -> RayFlags -> Bool
<= :: RayFlags -> RayFlags -> Bool
$c<= :: RayFlags -> RayFlags -> Bool
< :: RayFlags -> RayFlags -> Bool
$c< :: RayFlags -> RayFlags -> Bool
compare :: RayFlags -> RayFlags -> Ordering
$ccompare :: RayFlags -> RayFlags -> Ordering
Ord, Ptr RayFlags -> IO RayFlags
Ptr RayFlags -> Int -> IO RayFlags
Ptr RayFlags -> Int -> RayFlags -> IO ()
Ptr RayFlags -> RayFlags -> IO ()
RayFlags -> Int
forall b. Ptr b -> Int -> IO RayFlags
forall b. Ptr b -> Int -> RayFlags -> 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 RayFlags -> RayFlags -> IO ()
$cpoke :: Ptr RayFlags -> RayFlags -> IO ()
peek :: Ptr RayFlags -> IO RayFlags
$cpeek :: Ptr RayFlags -> IO RayFlags
pokeByteOff :: forall b. Ptr b -> Int -> RayFlags -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> RayFlags -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO RayFlags
$cpeekByteOff :: forall b. Ptr b -> Int -> IO RayFlags
pokeElemOff :: Ptr RayFlags -> Int -> RayFlags -> IO ()
$cpokeElemOff :: Ptr RayFlags -> Int -> RayFlags -> IO ()
peekElemOff :: Ptr RayFlags -> Int -> IO RayFlags
$cpeekElemOff :: Ptr RayFlags -> Int -> IO RayFlags
alignment :: RayFlags -> Int
$calignment :: RayFlags -> Int
sizeOf :: RayFlags -> Int
$csizeOf :: RayFlags -> Int
Storable, Eq RayFlags
RayFlags
Int -> RayFlags
RayFlags -> Bool
RayFlags -> Int
RayFlags -> Maybe Int
RayFlags -> RayFlags
RayFlags -> Int -> Bool
RayFlags -> Int -> RayFlags
RayFlags -> RayFlags -> RayFlags
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 :: RayFlags -> Int
$cpopCount :: RayFlags -> Int
rotateR :: RayFlags -> Int -> RayFlags
$crotateR :: RayFlags -> Int -> RayFlags
rotateL :: RayFlags -> Int -> RayFlags
$crotateL :: RayFlags -> Int -> RayFlags
unsafeShiftR :: RayFlags -> Int -> RayFlags
$cunsafeShiftR :: RayFlags -> Int -> RayFlags
shiftR :: RayFlags -> Int -> RayFlags
$cshiftR :: RayFlags -> Int -> RayFlags
unsafeShiftL :: RayFlags -> Int -> RayFlags
$cunsafeShiftL :: RayFlags -> Int -> RayFlags
shiftL :: RayFlags -> Int -> RayFlags
$cshiftL :: RayFlags -> Int -> RayFlags
isSigned :: RayFlags -> Bool
$cisSigned :: RayFlags -> Bool
bitSize :: RayFlags -> Int
$cbitSize :: RayFlags -> Int
bitSizeMaybe :: RayFlags -> Maybe Int
$cbitSizeMaybe :: RayFlags -> Maybe Int
testBit :: RayFlags -> Int -> Bool
$ctestBit :: RayFlags -> Int -> Bool
complementBit :: RayFlags -> Int -> RayFlags
$ccomplementBit :: RayFlags -> Int -> RayFlags
clearBit :: RayFlags -> Int -> RayFlags
$cclearBit :: RayFlags -> Int -> RayFlags
setBit :: RayFlags -> Int -> RayFlags
$csetBit :: RayFlags -> Int -> RayFlags
bit :: Int -> RayFlags
$cbit :: Int -> RayFlags
zeroBits :: RayFlags
$czeroBits :: RayFlags
rotate :: RayFlags -> Int -> RayFlags
$crotate :: RayFlags -> Int -> RayFlags
shift :: RayFlags -> Int -> RayFlags
$cshift :: RayFlags -> Int -> RayFlags
complement :: RayFlags -> RayFlags
$ccomplement :: RayFlags -> RayFlags
xor :: RayFlags -> RayFlags -> RayFlags
$cxor :: RayFlags -> RayFlags -> RayFlags
.|. :: RayFlags -> RayFlags -> RayFlags
$c.|. :: RayFlags -> RayFlags -> RayFlags
.&. :: RayFlags -> RayFlags -> RayFlags
$c.&. :: RayFlags -> RayFlags -> RayFlags
Bits)

pattern OpaqueKHR :: RayFlags
pattern $bOpaqueKHR :: RayFlags
$mOpaqueKHR :: forall {r}. RayFlags -> ((# #) -> r) -> ((# #) -> r) -> r
OpaqueKHR = RayFlags 0x1

pattern NoOpaqueKHR :: RayFlags
pattern $bNoOpaqueKHR :: RayFlags
$mNoOpaqueKHR :: forall {r}. RayFlags -> ((# #) -> r) -> ((# #) -> r) -> r
NoOpaqueKHR = RayFlags 0x2

pattern TerminateOnFirstHitKHR :: RayFlags
pattern $bTerminateOnFirstHitKHR :: RayFlags
$mTerminateOnFirstHitKHR :: forall {r}. RayFlags -> ((# #) -> r) -> ((# #) -> r) -> r
TerminateOnFirstHitKHR = RayFlags 0x4

pattern SkipClosestHitShaderKHR :: RayFlags
pattern $bSkipClosestHitShaderKHR :: RayFlags
$mSkipClosestHitShaderKHR :: forall {r}. RayFlags -> ((# #) -> r) -> ((# #) -> r) -> r
SkipClosestHitShaderKHR = RayFlags 0x8

pattern CullBackFacingTrianglesKHR :: RayFlags
pattern $bCullBackFacingTrianglesKHR :: RayFlags
$mCullBackFacingTrianglesKHR :: forall {r}. RayFlags -> ((# #) -> r) -> ((# #) -> r) -> r
CullBackFacingTrianglesKHR = RayFlags 0x10

pattern CullFrontFacingTrianglesKHR :: RayFlags
pattern $bCullFrontFacingTrianglesKHR :: RayFlags
$mCullFrontFacingTrianglesKHR :: forall {r}. RayFlags -> ((# #) -> r) -> ((# #) -> r) -> r
CullFrontFacingTrianglesKHR = RayFlags 0x20

pattern CullOpaqueKHR :: RayFlags
pattern $bCullOpaqueKHR :: RayFlags
$mCullOpaqueKHR :: forall {r}. RayFlags -> ((# #) -> r) -> ((# #) -> r) -> r
CullOpaqueKHR = RayFlags 0x40

pattern CullNoOpaqueKHR :: RayFlags
pattern $bCullNoOpaqueKHR :: RayFlags
$mCullNoOpaqueKHR :: forall {r}. RayFlags -> ((# #) -> r) -> ((# #) -> r) -> r
CullNoOpaqueKHR = RayFlags 0x80

pattern SkipTrianglesKHR :: RayFlags
pattern $bSkipTrianglesKHR :: RayFlags
$mSkipTrianglesKHR :: forall {r}. RayFlags -> ((# #) -> r) -> ((# #) -> r) -> r
SkipTrianglesKHR = RayFlags 0x100

pattern SkipAABBsKHR :: RayFlags
pattern $bSkipAABBsKHR :: RayFlags
$mSkipAABBsKHR :: forall {r}. RayFlags -> ((# #) -> r) -> ((# #) -> r) -> r
SkipAABBsKHR = RayFlags 0x200

pattern ForceOpacityMicromap2StateEXT :: RayFlags
pattern $bForceOpacityMicromap2StateEXT :: RayFlags
$mForceOpacityMicromap2StateEXT :: forall {r}. RayFlags -> ((# #) -> r) -> ((# #) -> r) -> r
ForceOpacityMicromap2StateEXT = RayFlags 0x400

toName :: IsString a => RayFlags -> a
toName :: forall a. IsString a => RayFlags -> a
toName RayFlags
x = case RayFlags
x of
  RayFlags
OpaqueKHR -> a
"OpaqueKHR"
  RayFlags
NoOpaqueKHR -> a
"NoOpaqueKHR"
  RayFlags
TerminateOnFirstHitKHR -> a
"TerminateOnFirstHitKHR"
  RayFlags
SkipClosestHitShaderKHR -> a
"SkipClosestHitShaderKHR"
  RayFlags
CullBackFacingTrianglesKHR -> a
"CullBackFacingTrianglesKHR"
  RayFlags
CullFrontFacingTrianglesKHR -> a
"CullFrontFacingTrianglesKHR"
  RayFlags
CullOpaqueKHR -> a
"CullOpaqueKHR"
  RayFlags
CullNoOpaqueKHR -> a
"CullNoOpaqueKHR"
  RayFlags
SkipTrianglesKHR -> a
"SkipTrianglesKHR"
  RayFlags
SkipAABBsKHR -> a
"SkipAABBsKHR"
  RayFlags
ForceOpacityMicromap2StateEXT -> a
"ForceOpacityMicromap2StateEXT"
  RayFlags
unknown -> forall a. IsString a => [Char] -> a
fromString forall a b. (a -> b) -> a -> b
$ [Char]
"RayFlags " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> [Char]
show RayFlags
unknown

instance Show RayFlags where
  show :: RayFlags -> [Char]
show = forall a. IsString a => RayFlags -> a
toName

fromName :: (IsString a, Eq a) => a -> Maybe RayFlags
fromName :: forall a. (IsString a, Eq a) => a -> Maybe RayFlags
fromName a
x = case a
x of
  a
"OpaqueKHR" -> forall a. a -> Maybe a
Just RayFlags
OpaqueKHR
  a
"NoOpaqueKHR" -> forall a. a -> Maybe a
Just RayFlags
NoOpaqueKHR
  a
"TerminateOnFirstHitKHR" -> forall a. a -> Maybe a
Just RayFlags
TerminateOnFirstHitKHR
  a
"SkipClosestHitShaderKHR" -> forall a. a -> Maybe a
Just RayFlags
SkipClosestHitShaderKHR
  a
"CullBackFacingTrianglesKHR" -> forall a. a -> Maybe a
Just RayFlags
CullBackFacingTrianglesKHR
  a
"CullFrontFacingTrianglesKHR" -> forall a. a -> Maybe a
Just RayFlags
CullFrontFacingTrianglesKHR
  a
"CullOpaqueKHR" -> forall a. a -> Maybe a
Just RayFlags
CullOpaqueKHR
  a
"CullNoOpaqueKHR" -> forall a. a -> Maybe a
Just RayFlags
CullNoOpaqueKHR
  a
"SkipTrianglesKHR" -> forall a. a -> Maybe a
Just RayFlags
SkipTrianglesKHR
  a
"SkipAABBsKHR" -> forall a. a -> Maybe a
Just RayFlags
SkipAABBsKHR
  a
"ForceOpacityMicromap2StateEXT" -> forall a. a -> Maybe a
Just RayFlags
ForceOpacityMicromap2StateEXT
  a
_unknown -> forall a. Maybe a
Nothing

instance Read RayFlags where
  readPrec :: ReadPrec RayFlags
readPrec = forall a. ReadPrec a -> ReadPrec a
Read.parens do
    Lex.Ident [Char]
s <- ReadPrec Lexeme
Read.lexP
    forall b a. b -> (a -> b) -> Maybe a -> b
maybe forall a. ReadPrec a
pfail forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ forall a. (IsString a, Eq a) => a -> Maybe RayFlags
fromName [Char]
s