Safe Haskell	None
Language	Haskell2010

FWGL.Shader

Description

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 #-}

Synopsis

Documentation

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

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) Source

A Shader with a VertexShaderOutput output.

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

A Shader with only a FragmentShaderOutput output.

newtype VertexShaderOutput Source

The position of the vertex.

Constructors

Vertex Vec4

Instances

ShaderType VertexShaderOutput
Typeable * VertexShaderOutput

newtype FragmentShaderOutput Source

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 Source

Instances

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

class ShaderType t Source

A type in the GPU.

Minimal complete definition

zero, toExpr, fromExpr, typeName, size

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

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 Source

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 Source

A GPU float.

Instances

data Sampler2D Source

A GPU sampler (sampler2D in GLSL).

Instances

ShaderType Sampler2D
Typeable * Sampler2D
GLES => UniformCPU ActiveTexture Sampler2D

data Vec2 Source

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 Source

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 Source

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 Source

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 Source

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 Source

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 Source

Floats in the CPU.

type CSampler2D = ActiveTexture Source

Samplers in the CPU.

type CVec2 = Vec2 Source

2D vectors in the CPU.

type CVec3 = Vec3 Source

3D vectors in the CPU.

type CVec4 = Vec4 Source

4D vectors in the CPU.

type CMat2 = Mat2 Source

2x2 matrices in the CPU.

type CMat3 = Mat3 Source

3x3 matrices in the CPU.

type CMat4 = Mat4 Source

4x4 matrices in the CPU.

negate :: GenType a => a -> a Source

fromInteger :: Integer -> Float Source

fromRational :: Rational -> Float Source

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

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

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

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

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

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

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

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

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

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

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

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

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

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

loop Source

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 Source

false :: Bool Source

store :: ShaderType a => a -> a Source

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

texture2D :: Sampler2D -> Vec2 -> Vec4 Source

radians :: GenType a => a -> a Source

degrees :: GenType a => a -> a Source

sin :: GenType a => a -> a Source

cos :: GenType a => a -> a Source

tan :: GenType a => a -> a Source

asin :: GenType a => a -> a Source

acos :: GenType a => a -> a Source

atan :: GenType a => a -> a Source

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

exp :: GenType a => a -> a Source

log :: GenType a => a -> a Source

exp2 :: GenType a => a -> a Source

log2 :: GenType a => a -> a Source

sqrt :: GenType a => a -> a Source

inversesqrt :: GenType a => a -> a Source

abs :: GenType a => a -> a Source

sign :: GenType a => a -> a Source

floor :: GenType a => a -> a Source

ceil :: GenType a => a -> a Source

fract :: GenType a => a -> a Source

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

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

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

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

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

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

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

length :: GenType a => a -> Float Source

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

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

cross :: Vec3 -> Vec3 -> Vec3 Source

normalize :: GenType a => a -> a Source

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

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

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

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

position :: Vec4 Source

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

fragColor :: Vec4 Source

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

data STList :: [*] -> * where Source

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.

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

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