FWGL.Shader

An example of shader variable:

        newtype Transform2 = Transform2 Mat3
                deriving (Typeable,
                          ShaderType, -- This is a type in the GPU (3x3 matrix).
                          UniformCPU CMat3) -- This can be used as an uniform
                                            -- and you can set it using a CPU
                                            -- 3x3 matrix
                                            -- (FWGL.Vector.Mat3)

An example of vertex shader:

        vertexShader :: VertexShader
        -- The types of the uniforms:
                                '[Transform2, View2, Depth]
        -- The types of the attributes:
                                '[Position2, UV]
        -- The types of the varying (outputs), excluding VertexShaderOutput.
                                '[UV]
        vertexShader 
        -- Set of uniforms:
                     (Transform2 trans :- View2 view :- Depth z :- N)
        -- Set of attributes:
                     (Position2 (Vec2 x y) :- uv@(UV _) :- N) =
        -- Matrix and vector multiplication:
                        let Vec3 x' y' _ = view * trans * Vec3 x y 1
        -- Set of outputs:
                        in Vertex (Vec4 x' y' z 1) -- Vertex position.
                           :- uv :- N

Required extensions:

{-# LANGUAGE DataKinds, RebindableSyntax, DeriveDataTypeable,
             GeneralizedNewtypeDeriving, GADTs #-}

Documentation

type Shader gs is os = STList gs -> STList is -> STList os

A function from a (heterogeneous) set of uniforms and a set of inputs (attributes or varyings) to a set of outputs (varyings).

type VertexShader g i o = Shader g i (VertexShaderOutput : o)

A Shader with a VertexShaderOutput output.

type FragmentShader g i = Shader g i (FragmentShaderOutput : [])

A Shader with only a FragmentShaderOutput output.

newtype VertexShaderOutput

The position of the vertex.

Constructors

Vertex Vec4

Instances

ShaderType VertexShaderOutput

Typeable * VertexShaderOutput

newtype FragmentShaderOutput

The RGBA color of the fragment (1.0 = #FF).

Constructors

Fragment Vec4

Instances

ShaderType FragmentShaderOutput

Typeable * FragmentShaderOutput

class Typeable a

The class Typeable allows a concrete representation of a type to be calculated.

Minimal complete definition

typeRep#

Instances

Typeable * Bool

Typeable * Char

Typeable * Double

Typeable * Float

Typeable * Int

Typeable * Int8

Typeable * Int16

Typeable * Int32

Typeable * Int64

Typeable * Integer

Typeable * Ordering

Typeable * RealWorld

Typeable * Word

Typeable * Word8

Typeable * Word16

Typeable * Word32

Typeable * Word64

Typeable * ()

Typeable * SpecConstrAnnotation

Typeable * ThreadId

Typeable * WordPtr

Typeable * IntPtr

Typeable * TypeRep

Typeable * TyCon

Typeable * Text

Typeable * Text

Typeable * LocalTime

Typeable * ZonedTime

Typeable * TimeOfDay

Typeable * TimeZone

Typeable * UTCTime

Typeable * NominalDiffTime

Typeable * Day

Typeable * Mat4

Typeable * Mat3

Typeable * Mat2

Typeable * Vec4

Typeable * Vec3

Typeable * Vec2

Typeable * Sampler2D

Typeable * Float

Typeable * FragmentShaderOutput

Typeable * VertexShaderOutput

Typeable * UV

Typeable * Position2

Typeable * View2

Typeable * Transform2

Typeable * Depth

Typeable * Image

Typeable * UV

Typeable * Normal3

Typeable * Position3

Typeable * View3

Typeable * Transform3

Typeable * Texture2

(Typeable (k1 -> k) s, Typeable k1 a) => Typeable k (s a)

Kind-polymorphic Typeable instance for type application

Typeable ((* -> *) -> Constraint) Alternative

Typeable ((* -> *) -> Constraint) Applicative

Typeable (* -> * -> * -> * -> * -> * -> * -> *) (,,,,,,)

Typeable (* -> * -> * -> * -> * -> * -> *) (,,,,,)

Typeable (* -> * -> * -> * -> * -> *) (,,,,)

Typeable (* -> * -> * -> * -> *) (,,,)

Typeable (* -> * -> * -> *) (,,)

Typeable (* -> * -> * -> *) STArray

Typeable (* -> * -> *) (->)

Typeable (* -> * -> *) Either

Typeable (* -> * -> *) (,)

Typeable (* -> * -> *) ST

Typeable (* -> * -> *) Array

Typeable (* -> * -> *) STRef

Typeable (* -> * -> *) HashMap

Typeable (* -> * -> *) MVector

Typeable (* -> * -> *) MVector

Typeable (* -> *) []

Typeable (* -> *) Ratio

Typeable (* -> *) StablePtr

Typeable (* -> *) IO

Typeable (* -> *) Ptr

Typeable (* -> *) FunPtr

Typeable (* -> *) Maybe

Typeable (* -> *) STM

Typeable (* -> *) TVar

Typeable (* -> *) MVar

Typeable (* -> *) IORef

Typeable (* -> *) Vector

Typeable (* -> *) Vector

Typeable (* -> Constraint) Monoid

Typeable (k -> *) (Proxy k)

Typeable (k -> k -> *) (Coercion k)

Typeable (k -> k -> *) ((:~:) k)

class AllTypeable xs

Instances

AllTypeable ([] *)

(Typeable * x, AllTypeable xs) => AllTypeable ((:) * x xs)

class ShaderType t

A type in the GPU.

Minimal complete definition

zero, toExpr, fromExpr, typeName, size

Instances

ShaderType Mat4

ShaderType Mat3

ShaderType Mat2

ShaderType Vec4

ShaderType Vec3

ShaderType Vec2

ShaderType Unknown

ShaderType Sampler2D

ShaderType Float

ShaderType FragmentShaderOutput

ShaderType VertexShaderOutput

ShaderType UV

ShaderType Position2

ShaderType View2

ShaderType Transform2

ShaderType Depth

ShaderType Image

ShaderType UV

ShaderType Normal3

ShaderType Position3

ShaderType View3

ShaderType Transform3

ShaderType Texture2

class Typeable g => UniformCPU c g | g -> c

CPU types convertible to GPU types (as uniforms).

Minimal complete definition

setUniform

Instances

GLES => UniformCPU Float Float

GLES => UniformCPU Vec2 Vec2

GLES => UniformCPU Vec3 Vec3

GLES => UniformCPU Vec4 Vec4

GLES => UniformCPU Mat2 Mat2

GLES => UniformCPU Mat3 Mat3

GLES => UniformCPU Mat4 Mat4

GLES => UniformCPU ActiveTexture Sampler2D

GLES => UniformCPU CMat4 View3

GLES => UniformCPU CMat4 Transform3

GLES => UniformCPU CMat3 View2

GLES => UniformCPU CMat3 Transform2

GLES => UniformCPU CSampler2D Image

GLES => UniformCPU CSampler2D Texture2

GLES => UniformCPU CFloat Depth

class Typeable g => AttributeCPU c g | g -> c

CPU types convertible to GPU types (as attributes).

Minimal complete definition

encodeAttribute, setAttribute

Instances

GLES => AttributeCPU Float Float

GLES => AttributeCPU Vec2 Vec2

GLES => AttributeCPU Vec3 Vec3

GLES => AttributeCPU Vec4 Vec4

GLES => AttributeCPU CVec3 Normal3

GLES => AttributeCPU CVec3 Position3

GLES => AttributeCPU CVec2 UV

GLES => AttributeCPU CVec2 Position2

GLES => AttributeCPU CVec2 UV

data Float

A GPU float.

Instances

Sum Float

ShaderType Float

Typeable * Float

GLES => AttributeCPU Float Float

GLES => UniformCPU Float Float

Mul Mat4 Float Mat4

Mul Mat3 Float Mat3

Mul Mat2 Float Mat2

Mul Vec4 Float Vec4

Mul Vec3 Float Vec3

Mul Vec2 Float Vec2

Mul Float Mat4 Mat4

Mul Float Mat3 Mat3

Mul Float Mat2 Mat2

Mul Float Vec4 Vec4

Mul Float Vec3 Vec3

Mul Float Vec2 Vec2

Mul Float Float Float

data Sampler2D

A GPU sampler (sampler2D in GLSL).

Instances

ShaderType Sampler2D

Typeable * Sampler2D

GLES => UniformCPU ActiveTexture Sampler2D

data Vec2

A GPU 2D vector. NB: This is a different type from Data.Vect.Float.Vec2.

Constructors

Vec2 Float Float

Instances

Sum Vec2

ShaderType Vec2

Typeable * Vec2

GLES => AttributeCPU Vec2 Vec2

GLES => UniformCPU Vec2 Vec2

Mul Mat2 Vec2 Vec2

Mul Vec2 Mat2 Vec2

Mul Vec2 Vec2 Vec2

Mul Vec2 Float Vec2

Mul Float Vec2 Vec2

data Vec3

A GPU 3D vector.

Constructors

Vec3 Float Float Float

Instances

Sum Vec3

ShaderType Vec3

Typeable * Vec3

GLES => AttributeCPU Vec3 Vec3

GLES => UniformCPU Vec3 Vec3

Mul Mat3 Vec3 Vec3

Mul Vec3 Mat3 Vec3

Mul Vec3 Vec3 Vec3

Mul Vec3 Float Vec3

Mul Float Vec3 Vec3

data Vec4

A GPU 4D vector.

Constructors

Vec4 Float Float Float Float

Instances

Sum Vec4

ShaderType Vec4

Typeable * Vec4

GLES => AttributeCPU Vec4 Vec4

GLES => UniformCPU Vec4 Vec4

Mul Mat4 Vec4 Vec4

Mul Vec4 Mat4 Vec4

Mul Vec4 Vec4 Vec4

Mul Vec4 Float Vec4

Mul Float Vec4 Vec4

data Mat2

A GPU 2x2 matrix.

Constructors

Mat2 Vec2 Vec2

Instances

Sum Mat2

ShaderType Mat2

Typeable * Mat2

GLES => UniformCPU Mat2 Mat2

Mul Mat2 Mat2 Mat2

Mul Mat2 Vec2 Vec2

Mul Mat2 Float Mat2

Mul Vec2 Mat2 Vec2

Mul Float Mat2 Mat2

data Mat3

A GPU 3x3 matrix.

Constructors

Mat3 Vec3 Vec3 Vec3

Instances

Sum Mat3

ShaderType Mat3

Typeable * Mat3

GLES => UniformCPU Mat3 Mat3

Mul Mat3 Mat3 Mat3

Mul Mat3 Vec3 Vec3

Mul Mat3 Float Mat3

Mul Vec3 Mat3 Vec3

Mul Float Mat3 Mat3

data Mat4

A GPU 4x4 matrix.

Constructors

Mat4 Vec4 Vec4 Vec4 Vec4

Instances

Sum Mat4

ShaderType Mat4

Typeable * Mat4

GLES => UniformCPU Mat4 Mat4

Mul Mat4 Mat4 Mat4

Mul Mat4 Vec4 Vec4

Mul Mat4 Float Mat4

Mul Vec4 Mat4 Vec4

Mul Float Mat4 Mat4

type CFloat = Float

Floats in the CPU.

type CSampler2D = ActiveTexture

Samplers in the CPU.

type CVec2 = Vec2

2D vectors in the CPU.

type CVec3 = Vec3

3D vectors in the CPU.

type CVec4 = Vec4

4D vectors in the CPU.

type CMat2 = Mat2

2x2 matrices in the CPU.

type CMat3 = Mat3

3x3 matrices in the CPU.

type CMat4 = Mat4

4x4 matrices in the CPU.

negate :: GenType a => a -> a

fromInteger :: Integer -> Float

fromRational :: Rational -> Float

(*) :: (Mul a b c, ShaderType a, ShaderType b, ShaderType c) => a -> b -> c infixl 7

(/) :: (Mul a b c, ShaderType a, ShaderType b, ShaderType c) => a -> b -> c infixl 7

(+) :: (Sum a, ShaderType a) => a -> a -> a infixl 6

(-) :: (Sum a, ShaderType a) => a -> a -> a infixl 6

(^) :: (ShaderType a, ShaderType b) => a -> b -> a infixr 8

(&&) :: Bool -> Bool -> Bool infixr 3

(||) :: Bool -> Bool -> Bool infixr 2

(==) :: ShaderType a => a -> a -> Bool infix 4

(>=) :: ShaderType a => a -> a -> Bool infix 4

(<=) :: ShaderType a => a -> a -> Bool infix 4

(<) :: ShaderType a => a -> a -> Bool infix 4

(>) :: ShaderType a => a -> a -> Bool infix 4

ifThenElse :: ShaderType a => Bool -> a -> a -> a

Rebound if. You don't need to use this function, with -XRebindableSyntax.

loop

Arguments

:: ShaderType a

=> Float

Maximum number of iterations (should be as low as possible, must be an integer literal)

-> a

Initial value

-> (Float -> a -> (a, Bool))

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

-> a

true :: Bool

false :: Bool

store :: ShaderType a => a -> a

Avoid executing this expression more than one time. Conditionals and loops imply it.

texture2D :: Sampler2D -> Vec2 -> Vec4

radians :: GenType a => a -> a

degrees :: GenType a => a -> a

sin :: GenType a => a -> a

cos :: GenType a => a -> a

tan :: GenType a => a -> a

asin :: GenType a => a -> a

acos :: GenType a => a -> a

atan :: GenType a => a -> a

atan2 :: GenType a => a -> a -> a

exp :: GenType a => a -> a

log :: GenType a => a -> a

exp2 :: GenType a => a -> a

log2 :: GenType a => a -> a

sqrt :: GenType a => a -> a

inversesqrt :: GenType a => a -> a

abs :: GenType a => a -> a

sign :: GenType a => a -> a

floor :: GenType a => a -> a

ceil :: GenType a => a -> a

fract :: GenType a => a -> a

mod :: (GenType a, GenType b) => a -> b -> a

min :: GenType a => a -> a -> a

max :: GenType a => a -> a -> a

clamp :: (GenType a, GenType b) => a -> b -> b -> a

mix :: (GenType a, GenType b) => a -> a -> b -> a

step :: GenType a => a -> a -> a

smoothstep :: (GenType a, GenType b) => b -> b -> a -> a

length :: GenType a => a -> Float

distance :: GenType a => a -> a -> Float

dot :: GenType a => a -> a -> Float

cross :: Vec3 -> Vec3 -> Vec3

normalize :: GenType a => a -> a

faceforward :: GenType a => a -> a -> a -> a

reflect :: GenType a => a -> a -> a

refract :: GenType a => a -> a -> Float -> a

matrixCompMult :: (Matrix a, Matrix b, Matrix c) => a -> b -> c

position :: Vec4

The position of the vertex (only works in the vertex shader).

fragColor :: Vec4

The color of the fragment (only works in the fragment shader).

data STList :: [*] -> * where

An heterogeneous set of ShaderTypes and Typeables.

Constructors

N :: STList []

(:-) :: (ShaderType a, Typeable a, IsMember a xs ~ False) => a -> STList xs -> STList (a : xs) infixr 4

(.) :: (b -> c) -> (a -> b) -> a -> c infixr 9

Function composition.

id :: a -> a

Identity function.

const :: a -> b -> a

Constant function.

flip :: (a -> b -> c) -> b -> a -> c

flip f takes its (first) two arguments in the reverse order of f.

($) :: (a -> b) -> a -> b infixr 0

Application operator. This operator is redundant, since ordinary application (f x) means the same as (f $ x). However, $ has low, right-associative binding precedence, so it sometimes allows parentheses to be omitted; for example:

    f $ g $ h x  =  f (g (h x))

It is also useful in higher-order situations, such as map ($ 0) xs, or zipWith ($) fs xs.

fst :: (a, b) -> a

Extract the first component of a pair.

snd :: (a, b) -> b

Extract the second component of a pair.