Hylogen.Expr

Internal AST representation.

Documentation

data GLSLType

Internal type tag

Constructors

GLSLFloat

GLSLVec2

GLSLVec3

GLSLVec4

GLSLBool

GLSLTexture

Instances

Eq GLSLType

Ord GLSLType

Show ExprMono

Show GLSLType

MuRef ExprMono

Currently only inlines uniforms.

Show a => Show (ExprMonoF a)

type DeRef ExprMono = ExprMonoF

data ExprForm

Internal form tag

Constructors

Uniform

Variable

Op1

Op1Pre

Op2

Op2Pre

Op3Pre

Op4Pre

Select

Access

Instances

Show ExprMono

Show ExprForm

MuRef ExprMono

Currently only inlines uniforms.

Show a => Show (ExprMonoF a)

type DeRef ExprMono = ExprMonoF

data Tree a

Rose tree. Internal AST data structure

Constructors

Tree

Fields

getElem :: a

getChildren :: [Tree a]

Instances

Show ExprMono

MuRef ExprMono

Currently only inlines uniforms.

Show a => Show (ExprMonoF a)

type DeRef ExprMono = ExprMonoF

type ExprMono = Tree (ExprForm, GLSLType, String)

Untyped Expr representation Carries type information in type tag

data Expr ty

Light type wrapper

Note the internal type tag is not directly dependent on the actual type!

We use the ToGLSLType typeclass to genenerate dependence from types to values

Constructors

Expr

Fields

getTypeTag :: ty

toMono :: Tree (ExprForm, GLSLType, String)

Instances

Num Booly

We use Num operators for Boolean arithmetic:

Veccable n => Floating (Vec n)

Veccable n => Fractional (Vec n)

Veccable n => Num (Vec n)

ToGLSLType ty => Show (Expr ty)

Veccable n => VectorSpace (Vec n)

Veccable n => InnerSpace (Vec n)

Veccable n => AdditiveGroup (Vec n)

((~) * a Vec1, (~) * b Vec1) => ToVec4 (a, b, Vec2)

((~) * a Vec1, (~) * c Vec1) => ToVec4 (a, Vec2, c)

((~) * b Vec1, (~) * c Vec1) => ToVec4 (Vec2, b, c)

type Scalar (Vec n) = Vec 1

class ToGLSLType ty where

Methods

toGLSLType :: ty -> GLSLType

Gives us dependence from typed singleton tags to untyped tags

tag :: ty

Singleton tag

Instances

ToGLSLType TextureType

ToGLSLType BoolyType

ToGLSLType (FloatVec 1)

ToGLSLType (FloatVec 2)

ToGLSLType (FloatVec 3)

ToGLSLType (FloatVec 4)

uniform :: forall a. ToGLSLType a => String -> Expr a

Uniform expression.

op1 :: forall a b. (ToGLSLType a, ToGLSLType b) => String -> Expr a -> Expr b

Unary operator. Most generally typed.

op1'' :: forall a. ToGLSLType a => String -> Expr a -> Expr a

Unary operator. Input and output values have the same type.

op1pre :: forall a b. (ToGLSLType a, ToGLSLType b) => String -> Expr a -> Expr b

Unary operator. Prefix function call style. Most generally typed.

op1pre'' :: forall a. ToGLSLType a => String -> Expr a -> Expr a

Unary operator. Prefix function call style. Input and output values have the same type.

op2 :: forall a b c. (ToGLSLType a, ToGLSLType b, ToGLSLType c) => String -> Expr a -> Expr b -> Expr c

Binary operator. Most generally typed.

op2' :: forall a c. (ToGLSLType a, ToGLSLType c) => String -> Expr a -> Expr a -> Expr c

Binary operator. Arguments have the same type.

op2'' :: forall a. ToGLSLType a => String -> Expr a -> Expr a -> Expr a

Binary operator. Input and output values have the same type.

op2pre :: forall a b c. (ToGLSLType a, ToGLSLType b, ToGLSLType c) => String -> Expr a -> Expr b -> Expr c

Binary operator. Prefix function call style. Most generally typed.

op2pre' :: forall a c. (ToGLSLType a, ToGLSLType c) => String -> Expr a -> Expr a -> Expr c

Binary operator. Prefix function call style. Arguments have the same type.

op2pre'' :: forall a. ToGLSLType a => String -> Expr a -> Expr a -> Expr a

Binary operator. Prefix function call style. Input and output values have the same type.

op3pre :: forall a b c d. (ToGLSLType a, ToGLSLType b, ToGLSLType c, ToGLSLType d) => String -> Expr a -> Expr b -> Expr c -> Expr d

Ternary operator. Prefix function call style. Most generally typed.

op3pre' :: forall a d. (ToGLSLType a, ToGLSLType d) => String -> Expr a -> Expr a -> Expr a -> Expr d

Ternary operator. Prefix function call style. Arguments have the same type.

op3pre'' :: forall a. ToGLSLType a => String -> Expr a -> Expr a -> Expr a -> Expr a

Ternary operator. Prefix function call style. Input and output values have the same type.

op4pre :: forall a b c d e. (ToGLSLType a, ToGLSLType b, ToGLSLType c, ToGLSLType d, ToGLSLType e) => String -> Expr a -> Expr b -> Expr c -> Expr d -> Expr e

Quaternary operator. Prefix function call style. Most generally typed.

op4pre' :: forall a e. (ToGLSLType a, ToGLSLType e) => String -> Expr a -> Expr a -> Expr a -> Expr a -> Expr e

Quaternary operator. Prefix function call style. Arguments have the same type.

op4pre'' :: forall a e. (ToGLSLType a, ToGLSLType e) => String -> Expr a -> Expr a -> Expr a -> Expr a -> Expr e

Quaternary operator. Prefix function call style. Input and output values have the same type.

data TreeF a b

Open tree type, to be used for explicit recursion with data-reify for preserving sharing.

Note the second argument of the constructor is a list of Maybe b's. We use Maybe's to determine whether or not a child expression gets inlined.

Constructors

TreeF

Fields

getElemF :: a

getChildrenF :: [Maybe b]

Instances

Functor (TreeF a)

Show a => Show (ExprMonoF a)

type ExprMonoF = TreeF (ExprForm, GLSLType, String, [ExprMono])

Open untyped expression representation, to be used for explicit recursion with data-reify for preserving sharing.

Note the presence of a list of closed ExprMono's in the tuple. We use this list to recover unshared child expressions when they need to be inlined.

emfStringAt :: Show a => ExprMonoF a -> Int -> String

Returns the string representation of the nth child of an open untyped expression, accounting for inlining