Graphics.Rendering.Ombra.Shader

Documentation

module Graphics.Rendering.Ombra.Shader.Language

data ShaderStage

Constructors

VertexShaderStage

FragmentShaderStage

data Shader s i o

A function that runs in the GPU.

Instances

Arrow (Shader s)

Methods

arr :: (b -> c) -> Shader s b c

first :: Shader s b c -> Shader s (b, d) (c, d)

second :: Shader s b c -> Shader s (d, b) (d, c)

(***) :: Shader s b c -> Shader s b' c' -> Shader s (b, b') (c, c')

(&&&) :: Shader s b c -> Shader s b c' -> Shader s b (c, c')

ArrowChoice (Shader s)

Methods

left :: Shader s b c -> Shader s (Either b d) (Either c d)

right :: Shader s b c -> Shader s (Either d b) (Either d c)

(+++) :: Shader s b c -> Shader s b' c' -> Shader s (Either b b') (Either c c')

(|||) :: Shader s b d -> Shader s c d -> Shader s (Either b c) d

ArrowApply (Shader s)

Methods

app :: Shader s (Shader s b c, b) c

Category * (Shader s)

Methods

id :: cat a a

(.) :: cat b c -> cat a b -> cat a c

(ShaderInput a, MultiShaderType b) => HasTrie (Shader s a b)

Associated Types

data (Shader s a b) :->: b :: *

Methods

trie :: (Shader s a b -> b) -> Shader s a b :->: b

untrie :: (Shader s a b :->: b) -> Shader s a b -> b

enumerate :: (Shader s a b :->: b) -> [(Shader s a b, b)]

(ShaderInput i, ShaderInput o) => Hashable (Shader s i o)

Methods

hashWithSalt :: Int -> Shader s i o -> Int

hash :: Shader s i o -> Int

(ShaderInput a, MultiShaderType b) => MultiShaderType (Shader s a b)

Associated Types

type ExprMST (Shader s a b) :: *

Methods

mapMST :: (forall x. ShaderType x => x -> x) -> Shader s a b -> Shader s a b

toExprMST :: Shader s a b -> ExprMST (Shader s a b)

fromExprMST :: ExprMST (Shader s a b) -> Shader s a b

data (:->:) (Shader s a b)

data (:->:) (Shader s a b) = SFunTrie ((:->:) (ExprMST (Shader s a b)) c)

type ExprMST (Shader s a b)

type ExprMST (Shader s a b)

type VertexShader = Shader VertexShaderStage

A shader that transforms vertices.

type FragmentShader = Shader FragmentShaderStage

A shader that transforms fragments.

Uniforms

uniform :: forall u s. Uniform u => Shader s (CPUUniform u) u

Add a shader variable that can be set with a CPU value.

(~<) :: Uniform u => Shader s (u, i) o -> CPUUniform u -> Shader s i o infixl 9

Add a uniform and directly set it with the second operand.

foldUniforms :: forall a u s. (ShaderInput a, ArrayUniform u, GLES) => Shader s ((a -> u -> a, a), [CPUBase u]) a

Create an array uniform and then fold over it with the given function and initial value.

Optimized shaders

data UniformSetter x

Instances

Monad UniformSetter

Methods

(>>=) :: UniformSetter a -> (a -> UniformSetter b) -> UniformSetter b

(>>) :: UniformSetter a -> UniformSetter b -> UniformSetter b

return :: a -> UniformSetter a

fail :: String -> UniformSetter a

Functor UniformSetter

Methods

fmap :: (a -> b) -> UniformSetter a -> UniformSetter b

(<$) :: a -> UniformSetter b -> UniformSetter a

Applicative UniformSetter

Methods

pure :: a -> UniformSetter a

(<*>) :: UniformSetter (a -> b) -> UniformSetter a -> UniformSetter b

(*>) :: UniformSetter a -> UniformSetter b -> UniformSetter b

(<*) :: UniformSetter a -> UniformSetter b -> UniformSetter a

shader :: (MultiShaderType i, MultiShaderType o) => Shader s i o -> Shader s i o

Create a shader function that can be reused efficiently. Ideally, every operation on G* and *Sampler types should be performed by a top level Shader created with this function, while arrow combinators and uniforms can appear anywhere.

sarr :: (MultiShaderType i, MultiShaderType o) => (i -> o) -> Shader s i o

shader . arr

shaderParam :: (HasTrie p, MultiShaderType i, MultiShaderType o) => Shader s (p, i) o -> Shader s (p, i) o

This variant of shader can be used with shaders that have a mostly static parameter. It will create a different shader every time the parameter changes to a new value, therefore parameters should not be used for things like model matrices (for which uniforms are more appropriate). Unlike uniforms, parameters can be used anywhere, in particular they can be used to change the shader structure. Shaders themselves can be used as parameters.

pshader :: (HasTrie p, MultiShaderType i, MultiShaderType o) => (p -> Shader s i o) -> p -> Shader s i o

See shaderParam. The result of partially applying this function is a function for which the same rules of shader apply (that is, it should be reused rather than recreated at every frame).

ushader :: (MultiShaderType i, MultiShaderType o) => (UniformSetter x -> Shader s i o) -> UniformSetter x -> Shader s i o

shader with an additional parameter that can be used to set the values of the uniforms. Like pshader, this should be used as a function of functions, not a function with two arguments.

pushader :: (HasTrie p, MultiShaderType i, MultiShaderType o) => (p -> UniformSetter x -> Shader s i o) -> p -> UniformSetter x -> Shader s i o

Combination of pshader and ushader.

uniform' :: Uniform u => Shader s (UniformSetter (CPUUniform u)) u

Like uniform but uses a UniformSetter.

(~<*) :: Uniform u => Shader s (u, i) o -> UniformSetter (CPUUniform u) -> Shader s i o infixl 9

Add a uniform and directly set it with a UniformSetter.

Fragment shader functionalities

data Fragment

Constructors

Fragment

Fields

• fragCoord :: GVec4

  The coordinates of the fragment.

• fragFrontFacing :: GBool

  If the fragment belongs to a front-facing primitive.

• dFdx :: forall a. GenType a => a -> a

  Partial derivative of the argument with respect to the window X coordinate.

• dFdy :: forall a. GenType a => a -> a

  Partial derivative of the argument with respect to the window Y coordinate.

• fwidth :: forall a. GenType a => a -> a

  Sum of the absolute values of dFdx and dFdy.

farr :: (MultiShaderType i, MultiShaderType o) => (Fragment -> i -> o) -> FragmentShader i o

This works like sarr but provides a Fragment.

fragment :: FragmentShader a Fragment

Loops

forLoop

Arguments

:: ShaderInput a

=> Int

Maximum number of iterations (should be as low as possible)

-> a

Initial value

-> (GInt -> a -> (a, GBool))

Iteration -> Old value -> (Next, Stop)

-> a

Repeatedly apply a function to a shader value. This is compiled to an actual for loop, therefore it won't duplicate the function code (doing that could slow down compilation or cause an out of memory error). The same applies to derived functions like foldGArray and foldUniforms.

foldGArray :: forall t n a. (ShaderType t, KnownNat n, ShaderInput a) => (a -> t -> a) -> a -> GArray n t -> a

Classes

class HasTrie (ExprMST a) => MultiShaderType a where

Types that contain zero or more ShaderTypes.

Associated Types

type ExprMST a

Methods

mapMST :: (forall x. ShaderType x => x -> x) -> a -> a

mapMST :: (Generic a, GMultiShaderType (Rep a)) => (forall x. ShaderType x => x -> x) -> a -> a

toExprMST :: a -> ExprMST a

toExprMST :: (Generic a, GMultiShaderType (Rep a), ExprMST a ~ GExprMST (Rep a)) => a -> ExprMST a

fromExprMST :: ExprMST a -> a

fromExprMST :: (Generic a, GMultiShaderType (Rep a), ExprMST a ~ GExprMST (Rep a)) => ExprMST a -> a

Instances

MultiShaderType ()

Associated Types

type ExprMST () :: *

Methods

mapMST :: (forall x. ShaderType x => x -> x) -> () -> ()

toExprMST :: () -> ExprMST ()

fromExprMST :: ExprMST () -> ()

MultiShaderType GMat4

Associated Types

type ExprMST GMat4 :: *

Methods

mapMST :: (forall x. ShaderType x => x -> x) -> GMat4 -> GMat4

toExprMST :: GMat4 -> ExprMST GMat4

fromExprMST :: ExprMST GMat4 -> GMat4

MultiShaderType GMat3

Associated Types

type ExprMST GMat3 :: *

Methods

mapMST :: (forall x. ShaderType x => x -> x) -> GMat3 -> GMat3

toExprMST :: GMat3 -> ExprMST GMat3

fromExprMST :: ExprMST GMat3 -> GMat3

MultiShaderType GMat2

Associated Types

type ExprMST GMat2 :: *

Methods

mapMST :: (forall x. ShaderType x => x -> x) -> GMat2 -> GMat2

toExprMST :: GMat2 -> ExprMST GMat2

fromExprMST :: ExprMST GMat2 -> GMat2

MultiShaderType GBVec4

Associated Types

type ExprMST GBVec4 :: *

Methods

mapMST :: (forall x. ShaderType x => x -> x) -> GBVec4 -> GBVec4

toExprMST :: GBVec4 -> ExprMST GBVec4

fromExprMST :: ExprMST GBVec4 -> GBVec4

MultiShaderType GBVec3

Associated Types

type ExprMST GBVec3 :: *

Methods

mapMST :: (forall x. ShaderType x => x -> x) -> GBVec3 -> GBVec3

toExprMST :: GBVec3 -> ExprMST GBVec3

fromExprMST :: ExprMST GBVec3 -> GBVec3

MultiShaderType GBVec2

Associated Types

type ExprMST GBVec2 :: *

Methods

mapMST :: (forall x. ShaderType x => x -> x) -> GBVec2 -> GBVec2

toExprMST :: GBVec2 -> ExprMST GBVec2

fromExprMST :: ExprMST GBVec2 -> GBVec2

MultiShaderType GIVec4

Associated Types

type ExprMST GIVec4 :: *

Methods

mapMST :: (forall x. ShaderType x => x -> x) -> GIVec4 -> GIVec4

toExprMST :: GIVec4 -> ExprMST GIVec4

fromExprMST :: ExprMST GIVec4 -> GIVec4

MultiShaderType GIVec3

Associated Types

type ExprMST GIVec3 :: *

Methods

mapMST :: (forall x. ShaderType x => x -> x) -> GIVec3 -> GIVec3

toExprMST :: GIVec3 -> ExprMST GIVec3

fromExprMST :: ExprMST GIVec3 -> GIVec3

MultiShaderType GIVec2

Associated Types

type ExprMST GIVec2 :: *

Methods

mapMST :: (forall x. ShaderType x => x -> x) -> GIVec2 -> GIVec2

toExprMST :: GIVec2 -> ExprMST GIVec2

fromExprMST :: ExprMST GIVec2 -> GIVec2

MultiShaderType GVec4

Associated Types

type ExprMST GVec4 :: *

Methods

mapMST :: (forall x. ShaderType x => x -> x) -> GVec4 -> GVec4

toExprMST :: GVec4 -> ExprMST GVec4

fromExprMST :: ExprMST GVec4 -> GVec4

MultiShaderType GVec3

Associated Types

type ExprMST GVec3 :: *

Methods

mapMST :: (forall x. ShaderType x => x -> x) -> GVec3 -> GVec3

toExprMST :: GVec3 -> ExprMST GVec3

fromExprMST :: ExprMST GVec3 -> GVec3

MultiShaderType GVec2

Associated Types

type ExprMST GVec2 :: *

Methods

mapMST :: (forall x. ShaderType x => x -> x) -> GVec2 -> GVec2

toExprMST :: GVec2 -> ExprMST GVec2

fromExprMST :: ExprMST GVec2 -> GVec2

MultiShaderType GInt

Associated Types

type ExprMST GInt :: *

Methods

mapMST :: (forall x. ShaderType x => x -> x) -> GInt -> GInt

toExprMST :: GInt -> ExprMST GInt

fromExprMST :: ExprMST GInt -> GInt

MultiShaderType GFloat

Associated Types

type ExprMST GFloat :: *

Methods

mapMST :: (forall x. ShaderType x => x -> x) -> GFloat -> GFloat

toExprMST :: GFloat -> ExprMST GFloat

fromExprMST :: ExprMST GFloat -> GFloat

MultiShaderType GBool

Associated Types

type ExprMST GBool :: *

Methods

mapMST :: (forall x. ShaderType x => x -> x) -> GBool -> GBool

toExprMST :: GBool -> ExprMST GBool

fromExprMST :: ExprMST GBool -> GBool

MultiShaderType DepthBufferSampler

Associated Types

type ExprMST DepthBufferSampler :: *

Methods

mapMST :: (forall x. ShaderType x => x -> x) -> DepthBufferSampler -> DepthBufferSampler

toExprMST :: DepthBufferSampler -> ExprMST DepthBufferSampler

fromExprMST :: ExprMST DepthBufferSampler -> DepthBufferSampler

MultiShaderType a => MultiShaderType [a]

Associated Types

type ExprMST [a] :: *

Methods

mapMST :: (forall x. ShaderType x => x -> x) -> [a] -> [a]

toExprMST :: [a] -> ExprMST [a]

fromExprMST :: ExprMST [a] -> [a]

FragmentShaderOutput o => MultiShaderType (GBufferSampler o)

Associated Types

type ExprMST (GBufferSampler o) :: *

Methods

mapMST :: (forall x. ShaderType x => x -> x) -> GBufferSampler o -> GBufferSampler o

toExprMST :: GBufferSampler o -> ExprMST (GBufferSampler o)

fromExprMST :: ExprMST (GBufferSampler o) -> GBufferSampler o

(ShaderInput a, MultiShaderType b) => MultiShaderType (a -> b)

Associated Types

type ExprMST (a -> b) :: *

Methods

mapMST :: (forall x. ShaderType x => x -> x) -> (a -> b) -> a -> b

toExprMST :: (a -> b) -> ExprMST (a -> b)

fromExprMST :: ExprMST (a -> b) -> a -> b

(MultiShaderType a, MultiShaderType b) => MultiShaderType (a, b)

Associated Types

type ExprMST (a, b) :: *

Methods

mapMST :: (forall x. ShaderType x => x -> x) -> (a, b) -> (a, b)

toExprMST :: (a, b) -> ExprMST (a, b)

fromExprMST :: ExprMST (a, b) -> (a, b)

(KnownNat n, ShaderType t) => MultiShaderType (GArray n t)

Associated Types

type ExprMST (GArray n t) :: *

Methods

mapMST :: (forall x. ShaderType x => x -> x) -> GArray n t -> GArray n t

toExprMST :: GArray n t -> ExprMST (GArray n t)

fromExprMST :: ExprMST (GArray n t) -> GArray n t

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

Associated Types

type ExprMST (a, b, c) :: *

Methods

mapMST :: (forall x. ShaderType x => x -> x) -> (a, b, c) -> (a, b, c)

toExprMST :: (a, b, c) -> ExprMST (a, b, c)

fromExprMST :: ExprMST (a, b, c) -> (a, b, c)

(ShaderInput a, MultiShaderType b) => MultiShaderType (Shader s a b)

Associated Types

type ExprMST (Shader s a b) :: *

Methods

mapMST :: (forall x. ShaderType x => x -> x) -> Shader s a b -> Shader s a b

toExprMST :: Shader s a b -> ExprMST (Shader s a b)

fromExprMST :: ExprMST (Shader s a b) -> Shader s a b

class MultiShaderType a => ShaderInput a where

Types that contain a finite amount of ShaderTypes.

Methods

buildMST :: (forall x. ShaderType x => Int -> x) -> Int -> (a, Int)

buildMST :: (Generic a, GShaderInput (Rep a)) => (forall x. ShaderType x => Int -> x) -> Int -> (a, Int)

foldrMST :: (forall x. ShaderType x => x -> b -> b) -> b -> a -> b

foldrMST :: (Generic a, GShaderInput (Rep a)) => (forall x. ShaderType x => x -> b -> b) -> b -> a -> b

Instances

ShaderInput ()

Methods

buildMST :: (forall x. ShaderType x => Int -> x) -> Int -> ((), Int)

foldrMST :: (forall x. ShaderType x => x -> b -> b) -> b -> () -> b

ShaderInput GMat4

Methods

buildMST :: (forall x. ShaderType x => Int -> x) -> Int -> (GMat4, Int)

foldrMST :: (forall x. ShaderType x => x -> b -> b) -> b -> GMat4 -> b

ShaderInput GMat3

Methods

buildMST :: (forall x. ShaderType x => Int -> x) -> Int -> (GMat3, Int)

foldrMST :: (forall x. ShaderType x => x -> b -> b) -> b -> GMat3 -> b

ShaderInput GMat2

Methods

buildMST :: (forall x. ShaderType x => Int -> x) -> Int -> (GMat2, Int)

foldrMST :: (forall x. ShaderType x => x -> b -> b) -> b -> GMat2 -> b

ShaderInput GBVec4

Methods

buildMST :: (forall x. ShaderType x => Int -> x) -> Int -> (GBVec4, Int)

foldrMST :: (forall x. ShaderType x => x -> b -> b) -> b -> GBVec4 -> b

ShaderInput GBVec3

Methods

buildMST :: (forall x. ShaderType x => Int -> x) -> Int -> (GBVec3, Int)

foldrMST :: (forall x. ShaderType x => x -> b -> b) -> b -> GBVec3 -> b

ShaderInput GBVec2

Methods

buildMST :: (forall x. ShaderType x => Int -> x) -> Int -> (GBVec2, Int)

foldrMST :: (forall x. ShaderType x => x -> b -> b) -> b -> GBVec2 -> b

ShaderInput GIVec4

Methods

buildMST :: (forall x. ShaderType x => Int -> x) -> Int -> (GIVec4, Int)

foldrMST :: (forall x. ShaderType x => x -> b -> b) -> b -> GIVec4 -> b

ShaderInput GIVec3

Methods

buildMST :: (forall x. ShaderType x => Int -> x) -> Int -> (GIVec3, Int)

foldrMST :: (forall x. ShaderType x => x -> b -> b) -> b -> GIVec3 -> b

ShaderInput GIVec2

Methods

buildMST :: (forall x. ShaderType x => Int -> x) -> Int -> (GIVec2, Int)

foldrMST :: (forall x. ShaderType x => x -> b -> b) -> b -> GIVec2 -> b

ShaderInput GVec4

Methods

buildMST :: (forall x. ShaderType x => Int -> x) -> Int -> (GVec4, Int)

foldrMST :: (forall x. ShaderType x => x -> b -> b) -> b -> GVec4 -> b

ShaderInput GVec3

Methods

buildMST :: (forall x. ShaderType x => Int -> x) -> Int -> (GVec3, Int)

foldrMST :: (forall x. ShaderType x => x -> b -> b) -> b -> GVec3 -> b

ShaderInput GVec2

Methods

buildMST :: (forall x. ShaderType x => Int -> x) -> Int -> (GVec2, Int)

foldrMST :: (forall x. ShaderType x => x -> b -> b) -> b -> GVec2 -> b

ShaderInput GInt

Methods

buildMST :: (forall x. ShaderType x => Int -> x) -> Int -> (GInt, Int)

foldrMST :: (forall x. ShaderType x => x -> b -> b) -> b -> GInt -> b

ShaderInput GFloat

Methods

buildMST :: (forall x. ShaderType x => Int -> x) -> Int -> (GFloat, Int)

foldrMST :: (forall x. ShaderType x => x -> b -> b) -> b -> GFloat -> b

ShaderInput GBool

Methods

buildMST :: (forall x. ShaderType x => Int -> x) -> Int -> (GBool, Int)

foldrMST :: (forall x. ShaderType x => x -> b -> b) -> b -> GBool -> b

ShaderInput DepthBufferSampler

Methods

buildMST :: (forall x. ShaderType x => Int -> x) -> Int -> (DepthBufferSampler, Int)

foldrMST :: (forall x. ShaderType x => x -> b -> b) -> b -> DepthBufferSampler -> b

FragmentShaderOutput o => ShaderInput (GBufferSampler o)

Methods

buildMST :: (forall x. ShaderType x => Int -> x) -> Int -> (GBufferSampler o, Int)

foldrMST :: (forall x. ShaderType x => x -> b -> b) -> b -> GBufferSampler o -> b

(ShaderInput a, ShaderInput b) => ShaderInput (a, b)

Methods

buildMST :: (forall x. ShaderType x => Int -> x) -> Int -> ((a, b), Int)

foldrMST :: (forall x. ShaderType x => x -> b -> b) -> b -> (a, b) -> b

(KnownNat n, ShaderType t) => ShaderInput (GArray n t)

Methods

buildMST :: (forall x. ShaderType x => Int -> x) -> Int -> (GArray n t, Int)

foldrMST :: (forall x. ShaderType x => x -> b -> b) -> b -> GArray n t -> b

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

Methods

buildMST :: (forall x. ShaderType x => Int -> x) -> Int -> ((a, b, c), Int)

foldrMST :: (forall x. ShaderType x => x -> b -> b) -> b -> (a, b, c) -> b

class (ShaderInput o, KnownNat (NFloats o)) => FragmentShaderOutput o where

Types that contain GFloats.

Associated Types

type NFloats o :: Nat

Methods

fromGFloats :: [GFloat] -> (o, [GFloat])

fromGFloats :: (Generic o, GFragmentShaderOutput (Rep o)) => [GFloat] -> (o, [GFloat])

toGFloats :: o -> [GFloat] -> [GFloat]

toGFloats :: (Generic o, GFragmentShaderOutput (Rep o)) => o -> [GFloat] -> [GFloat]

Instances

FragmentShaderOutput ()

Associated Types

type NFloats () :: Nat

Methods

fromGFloats :: [GFloat] -> ((), [GFloat])

toGFloats :: () -> [GFloat] -> [GFloat]

FragmentShaderOutput GVec4

Associated Types

type NFloats GVec4 :: Nat

Methods

fromGFloats :: [GFloat] -> (GVec4, [GFloat])

toGFloats :: GVec4 -> [GFloat] -> [GFloat]

FragmentShaderOutput GVec3

Associated Types

type NFloats GVec3 :: Nat

Methods

fromGFloats :: [GFloat] -> (GVec3, [GFloat])

toGFloats :: GVec3 -> [GFloat] -> [GFloat]

FragmentShaderOutput GVec2

Associated Types

type NFloats GVec2 :: Nat

Methods

fromGFloats :: [GFloat] -> (GVec2, [GFloat])

toGFloats :: GVec2 -> [GFloat] -> [GFloat]

FragmentShaderOutput GFloat

Associated Types

type NFloats GFloat :: Nat

Methods

fromGFloats :: [GFloat] -> (GFloat, [GFloat])

toGFloats :: GFloat -> [GFloat] -> [GFloat]

(FragmentShaderOutput a, FragmentShaderOutput b, KnownNat ((+) (NFloats a) (NFloats b))) => FragmentShaderOutput (a, b)

Associated Types

type NFloats (a, b) :: Nat

Methods

fromGFloats :: [GFloat] -> ((a, b), [GFloat])

toGFloats :: (a, b) -> [GFloat] -> [GFloat]

(FragmentShaderOutput a, FragmentShaderOutput b, FragmentShaderOutput c, KnownNat ((+) ((+) (NFloats a) (NFloats b)) (NFloats c))) => FragmentShaderOutput (a, b, c)

Associated Types

type NFloats (a, b, c) :: Nat

Methods

fromGFloats :: [GFloat] -> ((a, b, c), [GFloat])

toGFloats :: (a, b, c) -> [GFloat] -> [GFloat]

class MapShader f s | f -> s where

Minimal complete definition

mapShader

Methods

mapShader :: Shader s i o -> f i -> f o

Instances

MapShader Image FragmentShaderStage

Methods

mapShader :: Shader FragmentShaderStage i o -> Image i -> Image o

class ShaderInput a => Uniform a where

Types that contain uniform values.

Associated Types

type CPUUniform a

Methods

foldrUniform :: Proxy a -> (UniformValue -> b -> b) -> b -> CPUUniform a -> b

foldrUniform :: (Generic a, Generic (CPUUniform a), GUniform (Rep a) (Rep (CPUUniform a))) => Proxy a -> (UniformValue -> b -> b) -> b -> CPUUniform a -> b

Instances

Uniform ()

Associated Types

type CPUUniform () :: *

Methods

foldrUniform :: Proxy * () -> (UniformValue -> b -> b) -> b -> CPUUniform () -> b

GLES => Uniform GMat4

Associated Types

type CPUUniform GMat4 :: *

Methods

foldrUniform :: Proxy * GMat4 -> (UniformValue -> b -> b) -> b -> CPUUniform GMat4 -> b

GLES => Uniform GMat3

Associated Types

type CPUUniform GMat3 :: *

Methods

foldrUniform :: Proxy * GMat3 -> (UniformValue -> b -> b) -> b -> CPUUniform GMat3 -> b

GLES => Uniform GMat2

Associated Types

type CPUUniform GMat2 :: *

Methods

foldrUniform :: Proxy * GMat2 -> (UniformValue -> b -> b) -> b -> CPUUniform GMat2 -> b

GLES => Uniform GBVec4

Associated Types

type CPUUniform GBVec4 :: *

Methods

foldrUniform :: Proxy * GBVec4 -> (UniformValue -> b -> b) -> b -> CPUUniform GBVec4 -> b

GLES => Uniform GBVec3

Associated Types

type CPUUniform GBVec3 :: *

Methods

foldrUniform :: Proxy * GBVec3 -> (UniformValue -> b -> b) -> b -> CPUUniform GBVec3 -> b

GLES => Uniform GBVec2

Associated Types

type CPUUniform GBVec2 :: *

Methods

foldrUniform :: Proxy * GBVec2 -> (UniformValue -> b -> b) -> b -> CPUUniform GBVec2 -> b

GLES => Uniform GIVec4

Associated Types

type CPUUniform GIVec4 :: *

Methods

foldrUniform :: Proxy * GIVec4 -> (UniformValue -> b -> b) -> b -> CPUUniform GIVec4 -> b

GLES => Uniform GIVec3

Associated Types

type CPUUniform GIVec3 :: *

Methods

foldrUniform :: Proxy * GIVec3 -> (UniformValue -> b -> b) -> b -> CPUUniform GIVec3 -> b

GLES => Uniform GIVec2

Associated Types

type CPUUniform GIVec2 :: *

Methods

foldrUniform :: Proxy * GIVec2 -> (UniformValue -> b -> b) -> b -> CPUUniform GIVec2 -> b

GLES => Uniform GVec4

Associated Types

type CPUUniform GVec4 :: *

Methods

foldrUniform :: Proxy * GVec4 -> (UniformValue -> b -> b) -> b -> CPUUniform GVec4 -> b

GLES => Uniform GVec3

Associated Types

type CPUUniform GVec3 :: *

Methods

foldrUniform :: Proxy * GVec3 -> (UniformValue -> b -> b) -> b -> CPUUniform GVec3 -> b

GLES => Uniform GVec2

Associated Types

type CPUUniform GVec2 :: *

Methods

foldrUniform :: Proxy * GVec2 -> (UniformValue -> b -> b) -> b -> CPUUniform GVec2 -> b

GLES => Uniform GInt

Associated Types

type CPUUniform GInt :: *

Methods

foldrUniform :: Proxy * GInt -> (UniformValue -> b -> b) -> b -> CPUUniform GInt -> b

GLES => Uniform GFloat

Associated Types

type CPUUniform GFloat :: *

Methods

foldrUniform :: Proxy * GFloat -> (UniformValue -> b -> b) -> b -> CPUUniform GFloat -> b

GLES => Uniform GBool

Associated Types

type CPUUniform GBool :: *

Methods

foldrUniform :: Proxy * GBool -> (UniformValue -> b -> b) -> b -> CPUUniform GBool -> b

Uniform DepthBufferSampler

Associated Types

type CPUUniform DepthBufferSampler :: *

Methods

foldrUniform :: Proxy * DepthBufferSampler -> (UniformValue -> b -> b) -> b -> CPUUniform DepthBufferSampler -> b

FragmentShaderOutput o => Uniform (GBufferSampler o)

Associated Types

type CPUUniform (GBufferSampler o) :: *

Methods

foldrUniform :: Proxy * (GBufferSampler o) -> (UniformValue -> b -> b) -> b -> CPUUniform (GBufferSampler o) -> b

(Uniform a, Uniform b) => Uniform (a, b)

Associated Types

type CPUUniform (a, b) :: *

Methods

foldrUniform :: Proxy * (a, b) -> (UniformValue -> b -> b) -> b -> CPUUniform (a, b) -> b

(KnownNat n, ShaderType t, BaseUniform (GArray n t), GLES) => Uniform (GArray n t)

Associated Types

type CPUUniform (GArray n t) :: *

Methods

foldrUniform :: Proxy * (GArray n t) -> (UniformValue -> b -> b) -> b -> CPUUniform (GArray n t) -> b

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

Associated Types

type CPUUniform (a, b, c) :: *

Methods

foldrUniform :: Proxy * (a, b, c) -> (UniformValue -> b -> b) -> b -> CPUUniform (a, b, c) -> b