FWGL.Shader

Contents

• Types
  • GPU types
  • CPU types
• Functions
  • Math functions
    • Vector relational functions
  • Constructors
  • Operators
  • Rebinding functions
  • Prelude functions
• Variables

Description

        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)

        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

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

Synopsis

• type Shader gs is os = STList gs -> STList is -> STList os
• type VertexShader g i o = Shader g i (VertexShaderOutput : o)
• type FragmentShader g i = Shader g i (FragmentShaderOutput : `[]`)
• newtype VertexShaderOutput = Vertex Vec4
• newtype FragmentShaderOutput = Fragment Vec4
• class Typeable a
• class AllTypeable xs
• class ShaderType t
• class Typeable g => UniformCPU c g | g -> c
• class Typeable g => AttributeCPU c g | g -> c
• data STList :: [*] -> * where
  • N :: STList `[]`
  • (:-) :: (ShaderType a, Typeable a, IsMember a xs ~ False) => a -> STList xs -> STList (a : xs)
• data Bool
• data Float
• data Int
• data Sampler2D
• data SamplerCube
• data Vec2 = Vec2 Float Float
• data Vec3 = Vec3 Float Float Float
• data Vec4 = Vec4 Float Float Float Float
• data BVec2 = BVec2 Bool Bool
• data BVec3 = BVec3 Bool Bool Bool
• data BVec4 = BVec4 Bool Bool Bool Bool
• data IVec2 = IVec2 Int Int
• data IVec3 = IVec3 Int Int Int
• data IVec4 = IVec4 Int Int Int Int
• data Mat2 = Mat2 Vec2 Vec2
• data Mat3 = Mat3 Vec3 Vec3 Vec3
• data Mat4 = Mat4 Vec4 Vec4 Vec4 Vec4
• data Array n t
• type CInt = Int32
• type CBool = Int32
• type CFloat = Float
• type CSampler2D = ActiveTexture
• type CSamplerCube = ActiveTexture
• type CVec2 = Vec2
• type CVec3 = Vec3
• type CVec4 = Vec4
• type CIVec2 = IVec2
• type CIVec3 = IVec3
• type CIVec4 = IVec4
• type CBVec2 = IVec2
• type CBVec3 = IVec3
• type CBVec4 = IVec4
• type CMat2 = Mat2
• type CMat3 = Mat3
• type CMat4 = Mat4
• type CArray a = [a]
• toGPUBool :: Bool -> Int32
• loop :: ShaderType a => Int -> a -> (Int -> a -> (a, Bool)) -> a
• store :: ShaderType a => a -> a
• texture2D :: Sampler2D -> Vec2 -> Vec4
• texture2DBias :: Sampler2D -> Vec2 -> Float -> Vec4
• texture2DProj :: Sampler2D -> Vec3 -> Vec4
• texture2DProjBias :: Sampler2D -> Vec3 -> Float -> Vec4
• texture2DProj4 :: Sampler2D -> Vec4 -> Vec4
• texture2DProjBias4 :: Sampler2D -> Vec4 -> Float -> Vec4
• texture2DLod :: Sampler2D -> Vec2 -> Float -> Vec4
• texture2DProjLod :: Sampler2D -> Vec3 -> Float -> Vec4
• texture2DProjLod4 :: Sampler2D -> Vec4 -> Float -> Vec4
• arrayLength :: (ShaderType t, KnownNat n) => Array n t -> Int
• 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 :: GenTypeFloat a b => a -> b -> a
• min :: GenTypeFloat a b => a -> b -> a
• max :: GenTypeFloat a b => a -> b -> a
• clamp :: GenTypeFloat a b => a -> b -> b -> a
• mix :: GenTypeFloat a b => a -> a -> b -> a
• step :: GenTypeFloat a b => b -> a -> a
• smoothstep :: GenTypeFloat a 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
• class ShaderType a => VecOrd a
• class ShaderType a => VecEq a
• lessThan :: VecOrd a => a -> a -> Bool
• lessThanEqual :: VecOrd a => a -> a -> Bool
• greaterThan :: VecOrd a => a -> a -> Bool
• greaterThanEqual :: VecOrd a => a -> a -> Bool
• equal :: VecEq a => a -> a -> Bool
• notEqual :: VecEq a => a -> a -> Bool
• class ShaderType a => BoolVector a
• anyB :: BoolVector a => a -> Bool
• allB :: BoolVector a => a -> Bool
• notB :: BoolVector a => a -> Bool
• true :: Bool
• false :: Bool
• class ShaderType t => ToBool t
• bool :: ToBool t => t -> Bool
• class ShaderType t => ToInt t
• int :: ToInt t => t -> Int
• class ShaderType t => ToFloat t
• float :: ToFloat t => t -> Float
• type family Components t :: Nat
• data CompList count
• class ToCompList x n | x -> n
• (#) :: (ToCompList x xn, ToCompList y yn) => x -> y -> CompList (xn + yn)
• class ToVec2 t where
  • vec2 :: t -> Vec2
• class ToVec3 t where
  • vec3 :: t -> Vec3
• class ToVec4 t where
  • vec4 :: t -> Vec4
• class ToBVec2 t where
  • bvec2 :: t -> BVec2
• class ToBVec3 t where
  • bvec3 :: t -> BVec3
• class ToBVec4 t where
  • bvec4 :: t -> BVec4
• class ToIVec2 t where
  • ivec2 :: t -> IVec2
• class ToIVec3 t where
  • ivec3 :: t -> IVec3
• class ToIVec4 t where
  • ivec4 :: t -> IVec4
• class ToMat2 t where
  • mat2 :: t -> Mat2
• class ToMat3 t where
  • mat3 :: t -> Mat3
• class ToMat4 t where
  • mat4 :: t -> Mat4
• (*) :: (Mul aBase bBase a b c, ShaderType a, ShaderType b, ShaderType c) => a -> b -> c
• (/) :: (Arithmetic aBase bBase a b c, ShaderType a, ShaderType b, ShaderType c) => a -> b -> c
• (+) :: (Arithmetic aBase bBase a b c, ShaderType a, ShaderType b, ShaderType c) => a -> b -> c
• (-) :: (Arithmetic aBase bBase a b c, ShaderType a, ShaderType b, ShaderType c) => a -> b -> c
• (^) :: (ShaderType a, GenType a) => a -> a -> a
• (&&) :: Bool -> Bool -> Bool
• (||) :: Bool -> Bool -> Bool
• (==) :: ShaderType a => a -> a -> Bool
• (>=) :: ShaderType a => a -> a -> Bool
• (<=) :: ShaderType a => a -> a -> Bool
• (<) :: ShaderType a => a -> a -> Bool
• (>) :: ShaderType a => a -> a -> Bool
• (!) :: (ShaderType t, KnownNat n) => Array n t -> Int -> t
• fromInteger :: Num a => Integer -> a
• fromRational :: Rational -> Float
• ifThenElse :: ShaderType a => Bool -> a -> a -> a
• negate :: GenType a => a -> a
• (.) :: (b -> c) -> (a -> b) -> a -> c
• id :: a -> a
• const :: a -> b -> a
• flip :: (a -> b -> c) -> b -> a -> c
• ($) :: (a -> b) -> a -> b
• fst :: (a, b) -> a
• snd :: (a, b) -> b
• position :: Vec4
• fragColor :: Vec4
• fragCoord :: Vec4
• fragFrontFacing :: Bool

Types

GPU types

CPU types

Functions

Math functions

Vector relational functions

Constructors

vec2 0
mat2 $ Vec2 2 4 # Vec2 1 3
vec4 $ mat2 (0 # 1 # vec2 2) # 9  -- 9 is discarded
mat4 $ 5 # vec2 5 # Vec3 1 2 3 # Mat2 (vec2 0) (Vec2 1 2) # mat3 0
vec4 $ 1 # vec2 0 -- Not enough components, fails with "Couldn't match type
                  -- ‘'Prelude.False’ with 'Prelude.True’" (because
                  -- Components Vec4 <=? 3 ~ False).

Operators

Rebinding functions

Prelude functions

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

Variables