Graphics.GPipe.Expr

This module provides the DSL for shader operations in GPipe. The type S x a is an opaque type that represents a value of type a in a shader stage x, eg S F Float means a floating point value in a fragment stream.

Atomic shader type

data S x a

Instances

FragmentInput VBool

FragmentInput VWord

FragmentInput VInt

FragmentInput VFloat

Floating (S a Float)

Fractional (S a Float)

Num (S a Word)

Num (S a Int)

Num (S a Float)

Boolean (S a Bool)

IfB (S a Bool)

IfB (S a Word)

IfB (S a Int)

IfB (S a Float)

Eq x => EqB (S a x)

Ord x => OrdB (S a x)

Conjugate (S a Word)

Conjugate (S a Int)

Conjugate (S a Float)

TrivialConjugate (S a Word)

TrivialConjugate (S a Int)

TrivialConjugate (S a Float)

Convert (S x Word)

Convert (S x Int)

Convert (S x Float)

FloatingOrd (S x Float)

Real' (S x Float)

Integral' (S a Word)

Integral' (S a Int)

ShaderType (S x Bool) x

ShaderType (S x Word) x

ShaderType (S x Int) x

ShaderType (S x Float) x

type FragmentFormat VBool = FBool

type FragmentFormat VWord = FWord

type FragmentFormat VInt = FInt

type FragmentFormat VFloat = FFloat

type BooleanOf (S a x) = S a Bool

type ConvertFloat (S x Word) = S x Float

type ConvertFloat (S x Int) = S x Float

type ConvertFloat (S x Float) = S x Float

type ConvertInt (S x Word) = S x Int

type ConvertInt (S x Int) = S x Int

type ConvertInt (S x Float) = S x Int

type ConvertWord (S x Word) = S x Word

type ConvertWord (S x Int) = S x Word

type ConvertWord (S x Float) = S x Word

type ShaderBaseType (S x Bool) = S x Bool

type ShaderBaseType (S x Word) = S x Word

type ShaderBaseType (S x Int) = S x Int

type ShaderBaseType (S x Float) = S x Float

data V

Phantom type used as first argument in S V a that denotes that the shader value is a vertex value

Instances

FragmentInput VBool

FragmentInput VWord

FragmentInput VInt

FragmentInput VFloat

type FragmentFormat VBool = FBool

type FragmentFormat VWord = FWord

type FragmentFormat VInt = FInt

type FragmentFormat VFloat = FFloat

data F

Phantom type used as first argument in S F a that denotes that the shader value is a fragment value

type VFloat = S V Float

type VInt = S V Int

type VWord = S V Word

type VBool = S V Bool

type FFloat = S F Float

type FInt = S F Int

type FWord = S F Word

type FBool = S F Bool

Type classes where the Prelude ones are lacking

class Convert a where

Provides a common way to convert numeric types to integer and floating point representations.

Associated Types

type ConvertFloat a

type ConvertInt a

type ConvertWord a

Methods

toFloat :: a -> ConvertFloat a

Convert to a floating point number.

toInt :: a -> ConvertInt a

Convert to an integral number, using truncation if necessary.

toWord :: a -> ConvertWord a

Convert to an unsigned integral number, using truncation if necessary.

Instances

Convert Float

Convert Int

Convert Word

Convert (S x Word)

Convert (S x Int)

Convert (S x Float)

class Integral' a where

Methods

div' :: a -> a -> a

mod' :: a -> a -> a

Instances

Integral' Int

Integral' Int8

Integral' Int16

Integral' Int32

Integral' Word

Integral' Word8

Integral' Word16

Integral' Word32

Integral' a => Integral' (V4 a)

Integral' a => Integral' (V3 a)

Integral' a => Integral' (V2 a)

Integral' a => Integral' (V1 a)

Integral' a => Integral' (V0 a)

Integral' (S a Word)

Integral' (S a Int)

class Floating a => Real' a where

This class provides the GPU functions either not found in Prelude's numerical classes, or that has wrong types. Instances are also provided for normal Floats and Doubles.

Minimal complete definition

floor' | ceiling'

Methods

rsqrt :: a -> a

exp2 :: a -> a

log2 :: a -> a

floor' :: a -> a

ceiling' :: a -> a

fract' :: a -> a

mod'' :: a -> a -> a

mix :: a -> a -> a -> a

Instances

Real' Double

Real' Float

Real' a => Real' (V4 a)

Real' a => Real' (V3 a)

Real' a => Real' (V2 a)

Real' a => Real' (V1 a)

Real' a => Real' (V0 a)

Real' (S x Float)

class (IfB a, OrdB a, Floating a) => FloatingOrd a where

This class provides various order comparing functions

Minimal complete definition

Nothing

Methods

clamp :: a -> a -> a -> a

saturate :: a -> a

step :: a -> a -> a

smoothstep :: a -> a -> a -> a

Instances

FloatingOrd Double

FloatingOrd Float

FloatingOrd (S x Float)

Additional functions

dFdx :: FFloat -> FFloat

The derivative in x using local differencing of the rasterized value.

dFdy :: FFloat -> FFloat

The derivative in y using local differencing of the rasterized value.

fwidth :: FFloat -> FFloat

The sum of the absolute derivative in x and y using local differencing of the rasterized value.

Shader control structures

while :: forall a x. ShaderType a x => (a -> S x Bool) -> (a -> a) -> a -> a

while f g x will iteratively transform x with g as long as f generates true.

ifThen :: forall a x. ShaderType a x => S x Bool -> (a -> a) -> a -> a

ifThen c f x will return f x if c evaluates to true or x otherwise.

In most cases functionally equivalent to ifThenElse' but usually generate smaller shader code since the last argument is not inlined into the two branches, which also would affect implicit derivates (e.g. dFdx, dFdy or sampling using SampleAuto)

ifThenElse :: forall a b x. (ShaderType a x, ShaderType b x) => S x Bool -> (a -> b) -> (a -> b) -> a -> b

ifThenElse c f g x will return f x if c evaluates to true or g x otherwise.

In most cases functionally equivalent to ifThenElse' but usually generate smaller shader code since the last argument is not inlined into the two branches, which also would affect implicit derivates (e.g. dFdx, dFdy or sampling using SampleAuto)

ifThenElse' :: forall a x. ShaderType a x => S x Bool -> a -> a -> a

Works just like ifB, return second argument if first is true otherwise return third argument.

The difference from ifB is that it in most cases generate more efficient code when a is a compound type (e.g. a tuple or a vector). For simple types such as S x Float, ifThenElse' == ifB.

data ShaderBase a x

An opaque type

class ShaderType a x where

Constraint for types that may pass in and out of shader control structures. Define your own instances in terms of others and make sure to make toBase as lazy as possible.

Associated Types

type ShaderBaseType a

A base type that this type can convert into. Use the ShaderBaseType function on an existing instance of ShaderType to define this in your instance.

Methods

toBase :: x -> a -> ShaderBase (ShaderBaseType a) x

Convert this type to the shader base type. Make sure this is as lazy as possible (e.g. use tilde (~) on each pattern match).

fromBase :: x -> ShaderBase (ShaderBaseType a) x -> a

Convert back from the shader base type to this type.

Instances

ShaderType () x

ShaderType a x => ShaderType (V4 a) x

ShaderType a x => ShaderType (V3 a) x

ShaderType a x => ShaderType (V2 a) x

ShaderType a x => ShaderType (V1 a) x

ShaderType a x => ShaderType (V0 a) x

(ShaderType a x, ShaderType b x) => ShaderType (a, b) x

ShaderType (S x Bool) x

ShaderType (S x Word) x

ShaderType (S x Int) x

ShaderType (S x Float) x

(ShaderType a x, ShaderType b x, ShaderType c x) => ShaderType (a, b, c) x

(ShaderType a x, ShaderType b x, ShaderType c x, ShaderType d x) => ShaderType (a, b, c, d) x