Safe Haskell	Safe-Inferred
Language	Haskell2010

Engine.SpirV.Reflect

Contents

Block variables
Interface variables

Synopsis

invoke :: MonadIO m => FilePath -> m Module
data Reflect stages = Reflect {
- bindMap :: BindMap BlockBinding
- interfaces :: StageInterface stages
- inputStage :: Text
- inputs :: InterfaceBinds
}
type BindMap a = IntMap (IntMap a)
type StageInterface stages = stages (Maybe (InterfaceBinds, InterfaceBinds))
type InterfaceBinds = IntMap InterfaceBinding
type BlockBinding = (Text, DescriptorType, Maybe (Tree ([Maybe Text], BlockSignature)))
data BlockSignature = BlockSignature {
- offset :: Word32
- size :: Word32
- flags :: TypeFlags
- scalar :: Maybe Scalar
}
stagesBindMap :: (MonadIO m, MonadReader env m, HasLogFunc env, StageInfo stages) => stages (Maybe Module) -> m (BindMap BlockBinding)
moduleBindMap :: Module -> BindMap BlockBinding
blockTree :: [Maybe Text] -> BlockVariable -> Tree ([Maybe Text], BlockSignature)
bindMapUnionWith :: (a -> a -> Bool) -> BindMap a -> BindMap a -> Either (Int, Int, a, a) (BindMap a)
type InterfaceBinding = (Maybe Text, [Text], InterfaceSignature)
data InterfaceSignature = InterfaceSignature {
- format :: Format
- flags :: TypeFlags
- matrix :: Maybe Matrix
}
stagesInterfaceMap :: (MonadIO m, Traversable stages) => stages (Maybe Module) -> m (StageInterface stages)
moduleInterfaceBinds :: Module -> (InterfaceBinds, InterfaceBinds)
interfaceBinds :: StorageClass -> Vector InterfaceVariable -> InterfaceBinds
type IncompatibleInterfaces label = (label, label, Int, Maybe (InterfaceSignature, InterfaceSignature))
type CompatibleInterfaces label = (label, label, IntMap ([Text], Matching (Maybe Text)))
type Matching a = Either (a, a) a
interfaceCompatible :: (StageInfo stages, IsString label) => StageInterface stages -> Either (IncompatibleInterfaces label) [CompatibleInterfaces label]
inputStageInterface :: (StageInfo stages, IsString label) => StageInterface stages -> Maybe (label, InterfaceBinds)

Documentation

invoke :: MonadIO m => FilePath -> m Module Source #

data Reflect stages Source #

Constructors

Reflect
Fields bindMap :: BindMap BlockBinding interfaces :: StageInterface stages inputStage :: Text inputs :: InterfaceBinds

Instances

Instances details

Show (StageInterface stages) => Show (Reflect stages) Source #
Instance details Defined in Engine.SpirV.Reflect Methods showsPrec :: Int -> Reflect stages -> ShowS # show :: Reflect stages -> String # showList :: [Reflect stages] -> ShowS #
Eq (StageInterface stages) => Eq (Reflect stages) Source #
Instance details Defined in Engine.SpirV.Reflect Methods (==) :: Reflect stages -> Reflect stages -> Bool # (/=) :: Reflect stages -> Reflect stages -> Bool #

type BindMap a = IntMap (IntMap a) Source #

layout(set=X, binding=Y) ...

type StageInterface stages = stages (Maybe (InterfaceBinds, InterfaceBinds)) Source #

type InterfaceBinds = IntMap InterfaceBinding Source #

@layout(location=N)

Block variables

type BlockBinding = (Text, DescriptorType, Maybe (Tree ([Maybe Text], BlockSignature))) Source #

uniform Foo { ... } foo;

data BlockSignature Source #

Constructors

BlockSignature
Fields offset :: Word32 size :: Word32 flags :: TypeFlags scalar :: Maybe Scalar

Instances

Instances details

Show BlockSignature Source #
Instance details Defined in Engine.SpirV.Reflect Methods showsPrec :: Int -> BlockSignature -> ShowS # show :: BlockSignature -> String # showList :: [BlockSignature] -> ShowS #
Eq BlockSignature Source #
Instance details Defined in Engine.SpirV.Reflect Methods (==) :: BlockSignature -> BlockSignature -> Bool # (/=) :: BlockSignature -> BlockSignature -> Bool #
Ord BlockSignature Source #
Instance details Defined in Engine.SpirV.Reflect Methods compare :: BlockSignature -> BlockSignature -> Ordering # (<) :: BlockSignature -> BlockSignature -> Bool # (<=) :: BlockSignature -> BlockSignature -> Bool # (>) :: BlockSignature -> BlockSignature -> Bool # (>=) :: BlockSignature -> BlockSignature -> Bool # max :: BlockSignature -> BlockSignature -> BlockSignature # min :: BlockSignature -> BlockSignature -> BlockSignature #

stagesBindMap :: (MonadIO m, MonadReader env m, HasLogFunc env, StageInfo stages) => stages (Maybe Module) -> m (BindMap BlockBinding) Source #

moduleBindMap :: Module -> BindMap BlockBinding Source #

blockTree :: [Maybe Text] -> BlockVariable -> Tree ([Maybe Text], BlockSignature) Source #

bindMapUnionWith :: (a -> a -> Bool) -> BindMap a -> BindMap a -> Either (Int, Int, a, a) (BindMap a) Source #

Interface variables

type InterfaceBinding = (Maybe Text, [Text], InterfaceSignature) Source #

data InterfaceSignature Source #

Constructors

InterfaceSignature
Fields format :: Format flags :: TypeFlags matrix :: Maybe Matrix

Instances

Instances details

Show InterfaceSignature Source #
Instance details Defined in Engine.SpirV.Reflect Methods showsPrec :: Int -> InterfaceSignature -> ShowS # show :: InterfaceSignature -> String # showList :: [InterfaceSignature] -> ShowS #
Eq InterfaceSignature Source #
Instance details Defined in Engine.SpirV.Reflect Methods (==) :: InterfaceSignature -> InterfaceSignature -> Bool # (/=) :: InterfaceSignature -> InterfaceSignature -> Bool #
Ord InterfaceSignature Source #
Instance details Defined in Engine.SpirV.Reflect Methods compare :: InterfaceSignature -> InterfaceSignature -> Ordering # (<) :: InterfaceSignature -> InterfaceSignature -> Bool # (<=) :: InterfaceSignature -> InterfaceSignature -> Bool # (>) :: InterfaceSignature -> InterfaceSignature -> Bool # (>=) :: InterfaceSignature -> InterfaceSignature -> Bool # max :: InterfaceSignature -> InterfaceSignature -> InterfaceSignature # min :: InterfaceSignature -> InterfaceSignature -> InterfaceSignature #

stagesInterfaceMap :: (MonadIO m, Traversable stages) => stages (Maybe Module) -> m (StageInterface stages) Source #

moduleInterfaceBinds :: Module -> (InterfaceBinds, InterfaceBinds) Source #

interfaceBinds :: StorageClass -> Vector InterfaceVariable -> InterfaceBinds Source #

type IncompatibleInterfaces label = (label, label, Int, Maybe (InterfaceSignature, InterfaceSignature)) Source #

type CompatibleInterfaces label = (label, label, IntMap ([Text], Matching (Maybe Text))) Source #

type Matching a = Either (a, a) a Source #

interfaceCompatible :: (StageInfo stages, IsString label) => StageInterface stages -> Either (IncompatibleInterfaces label) [CompatibleInterfaces label] Source #

inputStageInterface :: (StageInfo stages, IsString label) => StageInterface stages -> Maybe (label, InterfaceBinds) Source #