module Data.SpirV.Reflect.Traits where

import Data.SpirV.Enum qualified as SpirV
import Data.SpirV.Enum.Dim qualified as Dim
import Data.SpirV.Enum.ImageFormat qualified as ImageFormat
import Data.Vector.Storable qualified as Storable
import Data.Word (Word32)
import GHC.Generics (Generic)

data Numeric = Numeric
  { Numeric -> Scalar
scalar :: Scalar
  , Numeric -> Vector
vector :: Vector
  , Numeric -> Matrix
matrix :: Matrix
  }
  deriving (Numeric -> Numeric -> Bool
(Numeric -> Numeric -> Bool)
-> (Numeric -> Numeric -> Bool) -> Eq Numeric
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Numeric -> Numeric -> Bool
== :: Numeric -> Numeric -> Bool
$c/= :: Numeric -> Numeric -> Bool
/= :: Numeric -> Numeric -> Bool
Eq, Eq Numeric
Eq Numeric =>
(Numeric -> Numeric -> Ordering)
-> (Numeric -> Numeric -> Bool)
-> (Numeric -> Numeric -> Bool)
-> (Numeric -> Numeric -> Bool)
-> (Numeric -> Numeric -> Bool)
-> (Numeric -> Numeric -> Numeric)
-> (Numeric -> Numeric -> Numeric)
-> Ord Numeric
Numeric -> Numeric -> Bool
Numeric -> Numeric -> Ordering
Numeric -> Numeric -> Numeric
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
$ccompare :: Numeric -> Numeric -> Ordering
compare :: Numeric -> Numeric -> Ordering
$c< :: Numeric -> Numeric -> Bool
< :: Numeric -> Numeric -> Bool
$c<= :: Numeric -> Numeric -> Bool
<= :: Numeric -> Numeric -> Bool
$c> :: Numeric -> Numeric -> Bool
> :: Numeric -> Numeric -> Bool
$c>= :: Numeric -> Numeric -> Bool
>= :: Numeric -> Numeric -> Bool
$cmax :: Numeric -> Numeric -> Numeric
max :: Numeric -> Numeric -> Numeric
$cmin :: Numeric -> Numeric -> Numeric
min :: Numeric -> Numeric -> Numeric
Ord, Int -> Numeric -> ShowS
[Numeric] -> ShowS
Numeric -> String
(Int -> Numeric -> ShowS)
-> (Numeric -> String) -> ([Numeric] -> ShowS) -> Show Numeric
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Numeric -> ShowS
showsPrec :: Int -> Numeric -> ShowS
$cshow :: Numeric -> String
show :: Numeric -> String
$cshowList :: [Numeric] -> ShowS
showList :: [Numeric] -> ShowS
Show, (forall x. Numeric -> Rep Numeric x)
-> (forall x. Rep Numeric x -> Numeric) -> Generic Numeric
forall x. Rep Numeric x -> Numeric
forall x. Numeric -> Rep Numeric x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Numeric -> Rep Numeric x
from :: forall x. Numeric -> Rep Numeric x
$cto :: forall x. Rep Numeric x -> Numeric
to :: forall x. Rep Numeric x -> Numeric
Generic)

emptyNumeric :: Numeric
emptyNumeric :: Numeric
emptyNumeric =
  Numeric
  { $sel:scalar:Numeric :: Scalar
scalar = Scalar
emptyScalar
  , $sel:vector:Numeric :: Vector
vector = Vector
emptyVector
  , $sel:matrix:Numeric :: Matrix
matrix = Matrix
emptyMatrix
  }

data Scalar = Scalar
  { Scalar -> Word32
width  :: Word32
  , Scalar -> Bool
signed :: Bool
  }
  deriving (Scalar -> Scalar -> Bool
(Scalar -> Scalar -> Bool)
-> (Scalar -> Scalar -> Bool) -> Eq Scalar
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Scalar -> Scalar -> Bool
== :: Scalar -> Scalar -> Bool
$c/= :: Scalar -> Scalar -> Bool
/= :: Scalar -> Scalar -> Bool
Eq, Eq Scalar
Eq Scalar =>
(Scalar -> Scalar -> Ordering)
-> (Scalar -> Scalar -> Bool)
-> (Scalar -> Scalar -> Bool)
-> (Scalar -> Scalar -> Bool)
-> (Scalar -> Scalar -> Bool)
-> (Scalar -> Scalar -> Scalar)
-> (Scalar -> Scalar -> Scalar)
-> Ord Scalar
Scalar -> Scalar -> Bool
Scalar -> Scalar -> Ordering
Scalar -> Scalar -> Scalar
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
$ccompare :: Scalar -> Scalar -> Ordering
compare :: Scalar -> Scalar -> Ordering
$c< :: Scalar -> Scalar -> Bool
< :: Scalar -> Scalar -> Bool
$c<= :: Scalar -> Scalar -> Bool
<= :: Scalar -> Scalar -> Bool
$c> :: Scalar -> Scalar -> Bool
> :: Scalar -> Scalar -> Bool
$c>= :: Scalar -> Scalar -> Bool
>= :: Scalar -> Scalar -> Bool
$cmax :: Scalar -> Scalar -> Scalar
max :: Scalar -> Scalar -> Scalar
$cmin :: Scalar -> Scalar -> Scalar
min :: Scalar -> Scalar -> Scalar
Ord, Int -> Scalar -> ShowS
[Scalar] -> ShowS
Scalar -> String
(Int -> Scalar -> ShowS)
-> (Scalar -> String) -> ([Scalar] -> ShowS) -> Show Scalar
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Scalar -> ShowS
showsPrec :: Int -> Scalar -> ShowS
$cshow :: Scalar -> String
show :: Scalar -> String
$cshowList :: [Scalar] -> ShowS
showList :: [Scalar] -> ShowS
Show, (forall x. Scalar -> Rep Scalar x)
-> (forall x. Rep Scalar x -> Scalar) -> Generic Scalar
forall x. Rep Scalar x -> Scalar
forall x. Scalar -> Rep Scalar x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Scalar -> Rep Scalar x
from :: forall x. Scalar -> Rep Scalar x
$cto :: forall x. Rep Scalar x -> Scalar
to :: forall x. Rep Scalar x -> Scalar
Generic)

emptyScalar :: Scalar
emptyScalar :: Scalar
emptyScalar = Scalar
  { $sel:width:Scalar :: Word32
width = Word32
0
  , $sel:signed:Scalar :: Bool
signed = Bool
False
  }

data Vector = Vector
  { Vector -> Word32
component_count :: Word32
  }
  deriving (Vector -> Vector -> Bool
(Vector -> Vector -> Bool)
-> (Vector -> Vector -> Bool) -> Eq Vector
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Vector -> Vector -> Bool
== :: Vector -> Vector -> Bool
$c/= :: Vector -> Vector -> Bool
/= :: Vector -> Vector -> Bool
Eq, Eq Vector
Eq Vector =>
(Vector -> Vector -> Ordering)
-> (Vector -> Vector -> Bool)
-> (Vector -> Vector -> Bool)
-> (Vector -> Vector -> Bool)
-> (Vector -> Vector -> Bool)
-> (Vector -> Vector -> Vector)
-> (Vector -> Vector -> Vector)
-> Ord Vector
Vector -> Vector -> Bool
Vector -> Vector -> Ordering
Vector -> Vector -> Vector
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
$ccompare :: Vector -> Vector -> Ordering
compare :: Vector -> Vector -> Ordering
$c< :: Vector -> Vector -> Bool
< :: Vector -> Vector -> Bool
$c<= :: Vector -> Vector -> Bool
<= :: Vector -> Vector -> Bool
$c> :: Vector -> Vector -> Bool
> :: Vector -> Vector -> Bool
$c>= :: Vector -> Vector -> Bool
>= :: Vector -> Vector -> Bool
$cmax :: Vector -> Vector -> Vector
max :: Vector -> Vector -> Vector
$cmin :: Vector -> Vector -> Vector
min :: Vector -> Vector -> Vector
Ord, Int -> Vector -> ShowS
[Vector] -> ShowS
Vector -> String
(Int -> Vector -> ShowS)
-> (Vector -> String) -> ([Vector] -> ShowS) -> Show Vector
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Vector -> ShowS
showsPrec :: Int -> Vector -> ShowS
$cshow :: Vector -> String
show :: Vector -> String
$cshowList :: [Vector] -> ShowS
showList :: [Vector] -> ShowS
Show, (forall x. Vector -> Rep Vector x)
-> (forall x. Rep Vector x -> Vector) -> Generic Vector
forall x. Rep Vector x -> Vector
forall x. Vector -> Rep Vector x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Vector -> Rep Vector x
from :: forall x. Vector -> Rep Vector x
$cto :: forall x. Rep Vector x -> Vector
to :: forall x. Rep Vector x -> Vector
Generic)

emptyVector :: Vector
emptyVector :: Vector
emptyVector = Vector
  { $sel:component_count:Vector :: Word32
component_count = Word32
0
  }

data Matrix = Matrix
  { Matrix -> Word32
column_count :: Word32
  , Matrix -> Word32
row_count    :: Word32
  , Matrix -> Word32
stride       :: Word32 -- ^ Measured in bytes
  }
  deriving (Matrix -> Matrix -> Bool
(Matrix -> Matrix -> Bool)
-> (Matrix -> Matrix -> Bool) -> Eq Matrix
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Matrix -> Matrix -> Bool
== :: Matrix -> Matrix -> Bool
$c/= :: Matrix -> Matrix -> Bool
/= :: Matrix -> Matrix -> Bool
Eq, Eq Matrix
Eq Matrix =>
(Matrix -> Matrix -> Ordering)
-> (Matrix -> Matrix -> Bool)
-> (Matrix -> Matrix -> Bool)
-> (Matrix -> Matrix -> Bool)
-> (Matrix -> Matrix -> Bool)
-> (Matrix -> Matrix -> Matrix)
-> (Matrix -> Matrix -> Matrix)
-> Ord Matrix
Matrix -> Matrix -> Bool
Matrix -> Matrix -> Ordering
Matrix -> Matrix -> Matrix
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
$ccompare :: Matrix -> Matrix -> Ordering
compare :: Matrix -> Matrix -> Ordering
$c< :: Matrix -> Matrix -> Bool
< :: Matrix -> Matrix -> Bool
$c<= :: Matrix -> Matrix -> Bool
<= :: Matrix -> Matrix -> Bool
$c> :: Matrix -> Matrix -> Bool
> :: Matrix -> Matrix -> Bool
$c>= :: Matrix -> Matrix -> Bool
>= :: Matrix -> Matrix -> Bool
$cmax :: Matrix -> Matrix -> Matrix
max :: Matrix -> Matrix -> Matrix
$cmin :: Matrix -> Matrix -> Matrix
min :: Matrix -> Matrix -> Matrix
Ord, Int -> Matrix -> ShowS
[Matrix] -> ShowS
Matrix -> String
(Int -> Matrix -> ShowS)
-> (Matrix -> String) -> ([Matrix] -> ShowS) -> Show Matrix
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Matrix -> ShowS
showsPrec :: Int -> Matrix -> ShowS
$cshow :: Matrix -> String
show :: Matrix -> String
$cshowList :: [Matrix] -> ShowS
showList :: [Matrix] -> ShowS
Show, (forall x. Matrix -> Rep Matrix x)
-> (forall x. Rep Matrix x -> Matrix) -> Generic Matrix
forall x. Rep Matrix x -> Matrix
forall x. Matrix -> Rep Matrix x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Matrix -> Rep Matrix x
from :: forall x. Matrix -> Rep Matrix x
$cto :: forall x. Rep Matrix x -> Matrix
to :: forall x. Rep Matrix x -> Matrix
Generic)

emptyMatrix :: Matrix
emptyMatrix :: Matrix
emptyMatrix = Matrix
  { $sel:column_count:Matrix :: Word32
column_count = Word32
0
  , $sel:row_count:Matrix :: Word32
row_count = Word32
0
  , $sel:stride:Matrix :: Word32
stride = Word32
0
  }

data Array = Array
  { Array -> Word32
dims_count :: Word32
  , Array -> Vector Word32
dims       :: Storable.Vector Word32
  , Array -> Maybe Word32
stride     :: Maybe Word32
  }
  deriving (Array -> Array -> Bool
(Array -> Array -> Bool) -> (Array -> Array -> Bool) -> Eq Array
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Array -> Array -> Bool
== :: Array -> Array -> Bool
$c/= :: Array -> Array -> Bool
/= :: Array -> Array -> Bool
Eq, Eq Array
Eq Array =>
(Array -> Array -> Ordering)
-> (Array -> Array -> Bool)
-> (Array -> Array -> Bool)
-> (Array -> Array -> Bool)
-> (Array -> Array -> Bool)
-> (Array -> Array -> Array)
-> (Array -> Array -> Array)
-> Ord Array
Array -> Array -> Bool
Array -> Array -> Ordering
Array -> Array -> Array
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
$ccompare :: Array -> Array -> Ordering
compare :: Array -> Array -> Ordering
$c< :: Array -> Array -> Bool
< :: Array -> Array -> Bool
$c<= :: Array -> Array -> Bool
<= :: Array -> Array -> Bool
$c> :: Array -> Array -> Bool
> :: Array -> Array -> Bool
$c>= :: Array -> Array -> Bool
>= :: Array -> Array -> Bool
$cmax :: Array -> Array -> Array
max :: Array -> Array -> Array
$cmin :: Array -> Array -> Array
min :: Array -> Array -> Array
Ord, Int -> Array -> ShowS
[Array] -> ShowS
Array -> String
(Int -> Array -> ShowS)
-> (Array -> String) -> ([Array] -> ShowS) -> Show Array
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Array -> ShowS
showsPrec :: Int -> Array -> ShowS
$cshow :: Array -> String
show :: Array -> String
$cshowList :: [Array] -> ShowS
showList :: [Array] -> ShowS
Show, (forall x. Array -> Rep Array x)
-> (forall x. Rep Array x -> Array) -> Generic Array
forall x. Rep Array x -> Array
forall x. Array -> Rep Array x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Array -> Rep Array x
from :: forall x. Array -> Rep Array x
$cto :: forall x. Rep Array x -> Array
to :: forall x. Rep Array x -> Array
Generic)

emptyArray :: Array
emptyArray :: Array
emptyArray = Array
  { $sel:dims_count:Array :: Word32
dims_count = Word32
0
  , $sel:dims:Array :: Vector Word32
dims = Vector Word32
forall a. Monoid a => a
mempty
  , $sel:stride:Array :: Maybe Word32
stride = Maybe Word32
forall a. Maybe a
Nothing
  }

data Image = Image
  { Image -> Dim
dim          :: SpirV.Dim
  , Image -> Word32
depth        :: Word32
  , Image -> Word32
arrayed      :: Word32
  , Image -> Word32
ms           :: Word32 -- ^ 0: single-sampled, 1: multisampled
  , Image -> Word32
sampled      :: Word32
  , Image -> ImageFormat
image_format :: SpirV.ImageFormat
  }
  deriving (Image -> Image -> Bool
(Image -> Image -> Bool) -> (Image -> Image -> Bool) -> Eq Image
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Image -> Image -> Bool
== :: Image -> Image -> Bool
$c/= :: Image -> Image -> Bool
/= :: Image -> Image -> Bool
Eq, Eq Image
Eq Image =>
(Image -> Image -> Ordering)
-> (Image -> Image -> Bool)
-> (Image -> Image -> Bool)
-> (Image -> Image -> Bool)
-> (Image -> Image -> Bool)
-> (Image -> Image -> Image)
-> (Image -> Image -> Image)
-> Ord Image
Image -> Image -> Bool
Image -> Image -> Ordering
Image -> Image -> Image
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
$ccompare :: Image -> Image -> Ordering
compare :: Image -> Image -> Ordering
$c< :: Image -> Image -> Bool
< :: Image -> Image -> Bool
$c<= :: Image -> Image -> Bool
<= :: Image -> Image -> Bool
$c> :: Image -> Image -> Bool
> :: Image -> Image -> Bool
$c>= :: Image -> Image -> Bool
>= :: Image -> Image -> Bool
$cmax :: Image -> Image -> Image
max :: Image -> Image -> Image
$cmin :: Image -> Image -> Image
min :: Image -> Image -> Image
Ord, Int -> Image -> ShowS
[Image] -> ShowS
Image -> String
(Int -> Image -> ShowS)
-> (Image -> String) -> ([Image] -> ShowS) -> Show Image
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Image -> ShowS
showsPrec :: Int -> Image -> ShowS
$cshow :: Image -> String
show :: Image -> String
$cshowList :: [Image] -> ShowS
showList :: [Image] -> ShowS
Show, (forall x. Image -> Rep Image x)
-> (forall x. Rep Image x -> Image) -> Generic Image
forall x. Rep Image x -> Image
forall x. Image -> Rep Image x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Image -> Rep Image x
from :: forall x. Image -> Rep Image x
$cto :: forall x. Rep Image x -> Image
to :: forall x. Rep Image x -> Image
Generic)

emptyImage :: Image
emptyImage :: Image
emptyImage = Image
  { $sel:dim:Image :: Dim
dim = Dim
Dim.Dim1D
  , $sel:depth:Image :: Word32
depth = Word32
0
  , $sel:arrayed:Image :: Word32
arrayed = Word32
0
  , $sel:ms:Image :: Word32
ms = Word32
0
  , $sel:sampled:Image :: Word32
sampled = Word32
0
  , $sel:image_format:Image :: ImageFormat
image_format = ImageFormat
ImageFormat.Unknown
  }