Graphics.Luminance.Shader.Program

Shader program creation

data Program u

Shader program.

Instances

Eq u => Eq (Program u)

Show u => Show (Program u)

programID :: Program u -> GLuint

createProgram :: (HasProgramError e, MonadError e m, MonadIO m, MonadResource m) => [Stage] -> ((forall a. UniformName a -> UniformInterface m (U a)) -> UniformInterface m i) -> m (Program i)

Create a new shader Program.

That function takes a list of Stages and a uniform interface builder function and yields a Program and the interface.

The builder function takes a function you can use to retrieve uniforms. You can pass values of type UniformName to identify the uniform you want to retrieve. If the uniform can’t be retrieved, throws InactiveUniform.

In the end, you get the new Program and a polymorphic value you can choose the type of in the function you pass as argument. You can use that value to gather uniforms for instance.

createProgram_ :: (HasProgramError e, MonadError e m, MonadIO m, MonadResource m) => [Stage] -> m (Program ())

A simpler version of createProgram. That function assumes you don’t need a uniform interface and then just returns the Program.

Uniform

class Uniform a

Class of types that can be sent down to shaders. That class is closed because shaders cannot handle a lot of uniform types. However, you should have a look at the U documentation for further information about how to augment the scope of the types you can send down to shaders.

Minimal complete definition

toU

Instances

Uniform Float

Uniform Int32

Uniform Word32

Uniform ()

Uniform [Float]

Uniform [Int32]

Uniform [Word32]

Uniform [(Float, Float)]

Uniform [(Int32, Int32)]

Uniform [(Word32, Word32)]

Uniform [(Float, Float, Float)]

Uniform [(Int32, Int32, Int32)]

Uniform [(Word32, Word32, Word32)]

Uniform [(Float, Float, Float, Float)]

Uniform [(Int32, Int32, Int32, Int32)]

Uniform [(Word32, Word32, Word32, Word32)]

Uniform [M44 Float]

Uniform [V Nat 2 Float]

Uniform [V Nat 2 Int32]

Uniform [V Nat 2 Word32]

Uniform [V Nat 3 Float]

Uniform [V Nat 3 Int32]

Uniform [V Nat 3 Word32]

Uniform [V Nat 4 Float]

Uniform [V Nat 4 Int32]

Uniform [V Nat 4 Word32]

Uniform [V4 Float]

Uniform [V4 Int32]

Uniform [V4 Word32]

Uniform [V3 Float]

Uniform [V3 Int32]

Uniform [V3 Word32]

Uniform [V2 Float]

Uniform [V2 Int32]

Uniform [V2 Word32]

Uniform (M44 Float)

Uniform (V4 Float)

Uniform (V4 Int32)

Uniform (V4 Word32)

Uniform (V3 Float)

Uniform (V3 Int32)

Uniform (V3 Word32)

Uniform (V2 Float)

Uniform (V2 Int32)

Uniform (V2 Word32)

Pixel f => Uniform (Cubemap f)

Pixel f => Uniform (Texture1D f)

Pixel f => Uniform (Texture2D f)

Pixel f => Uniform (Texture3D f)

Uniform (Float, Float)

Uniform (Int32, Int32)

Uniform (Word32, Word32)

Uniform (Float, Float, Float)

Uniform (Int32, Int32, Int32)

Uniform (Word32, Word32, Word32)

Uniform (V Nat 2 Float)

Uniform (V Nat 2 Int32)

Uniform (V Nat 2 Word32)

Uniform (V Nat 3 Float)

Uniform (V Nat 3 Int32)

Uniform (V Nat 3 Word32)

Uniform (V Nat 4 Float)

Uniform (V Nat 4 Int32)

Uniform (V Nat 4 Word32)

Uniform (Float, Float, Float, Float)

Uniform (Int32, Int32, Int32, Int32)

Uniform (Word32, Word32, Word32, Word32)

data U a

A shader uniform. U a doesn’t hold any value. It’s more like a mapping between the host code and the shader the uniform was retrieved from.

U is contravariant in its argument. That means that you can use contramap to build more interesting uniform types.

Another interesting part is the fact that U is also monoidal. You can accumulate several of them with '(<>)' if they have the same type. That means that you can join them so that when you pass an actual value, it gets shared inside the resulting value.

The '()' instance doesn’t do anything and doesn’t even use its argument.

Instances

Contravariant U

data U'

Instances

Monoid U'

Semigroup U'

(.=) :: U a -> a -> U'

Feed U a with a value.

updateUniforms :: MonadIO m => Program a -> (a -> U') -> m ()

Update uniforms in a program. That function enables you to update only the uniforms you want and not the whole.

If you want to update several uniforms (not only one), you can use the 'Semigroup'/'Monoid' instances (use '(<>)' or 'sconcat'/'mconcat' for instance).

data UniformInterface m a

Instances

Monad m => Monad (UniformInterface m)

Functor m => Functor (UniformInterface m)

Monad m => Applicative (UniformInterface m)

data UniformName :: * -> * where

Possible way to name uniform values.

Constructors

UniformName :: Uniform a => String -> UniformName a

UniformSemantic :: Uniform a => Natural -> UniformName a

UniformBlockName :: UniformBlock a => String -> UniformName (Buffer rw (UB a))

data SomeUniformName

A uniform name with type-erasure. You can only access the constructors and the carried name but you can’t reconstruct the phantom type.

Constructors

forall a . SomeUniformName (UniformName a)

Instances

Eq SomeUniformName

Show SomeUniformName

Uniform block

class UniformBlock a

Instances

UniformBlock Bool

UniformBlock Float

UniformBlock Int32

UniformBlock Word32

(Storable a, UniformBlock a) => UniformBlock (V4 a)

(Storable a, UniformBlock a) => UniformBlock (V3 a)

(Storable a, UniformBlock a) => UniformBlock (V2 a)

(UniformBlock a, UniformBlock b) => UniformBlock (a, b)

(UniformBlock a, UniformBlock b) => UniformBlock ((:.) a b)

(UniformBlock a, UniformBlock b, UniformBlock c) => UniformBlock (a, b, c)

(UniformBlock a, UniformBlock b, UniformBlock c, UniformBlock d) => UniformBlock (a, b, c, d)

newtype UB a

Constructors

UB

Fields

unUB :: a

Instances

Functor UB

Foldable UB

Traversable UB

Eq a => Eq (UB a)

Ord a => Ord (UB a)

Show a => Show (UB a)

UniformBlock a => Storable (UB a)

Error handling

data ProgramError

Shader program error.

'LinkFailed reason' happens when a program fails to link. reason contains the error message.

'InactiveUniform uni' happens at linking when a uniform is inactive in the program; that is, unused or semantically set to a negative value.

Constructors

LinkFailed String

InactiveUniform SomeUniformName

Instances

Eq ProgramError

Show ProgramError

class HasProgramError a where

Types that can handle ProgramError – read as, “have”.

Methods

fromProgramError :: ProgramError -> a

Re-exported

(<>) :: Semigroup a => a -> a -> a

An associative operation.

(a <> b) <> c = a <> (b <> c)

If a is also a Monoid we further require

(<>) = mappend

sconcat :: Semigroup a => NonEmpty a -> a

Reduce a non-empty list with <>

The default definition should be sufficient, but this can be overridden for efficiency.