{-|
Module      : HaGL
Copyright   : (c) Simeon Krastnikov, 2022-2023
License     : MIT
Maintainer  : Simeon Krastnikov <skrastnikov@gmail.com>
Stability   : experimental

This module exports everything that comprises the core language.

It is best used with the following extensions enabled: 
@GADTs@, @DataKinds@, @ViewPatterns@, @FlexibleContexts@.

Note that quite a few of the exported functions clash with unrelated
ones from Prelude ('max', 'length', 'mod', 'any', etc.) or class methods
with identical behaviour ('abs', 'sin', etc.), in an effort to prioritize
consistency with GLSL function naming.

In summary, this module can be imported as follows:

@
    &#x7b;-\# LANGUAGE GADTs \#-&#x7d;
    &#x7b;-\# LANGUAGE DataKinds \#-&#x7d;
    &#x7b;-\# LANGUAGE ViewPatterns \#-&#x7d;
    &#x7b;-\# LANGUAGE FlexibleContexts \#-&#x7d;

    import Prelude hiding (max, sin, cos, ...)

    import Graphics.HaGL
@

HaGL expressions have the type 'GLExpr' (d ::  'GLDomain') t,
where @d@ is the domain of computation and @t@ is the underlying numeric type, 
which is always an instance of 'GLType'. Here are some example expressions:

@
    -- A vertex attribute constructed from its input values on three vertices
    x :: GLExpr VertexDomain Float
    x = vert [-1, 0, 1]

    -- Numeric operators and functions like (+) and sin can handle generic
    -- expressions. Note that in this example the domain of the inputs to
    -- these functions is VertexDomain, so we know that these functions will 
    -- be computed in a vertex shader.
    y :: GLExpr VertexDomain Float
    y = sin (2 * x + 1)

    -- 'frag x' is a a fragment variable corresponding to an interpolation of
    -- the value of x at the vertices that define its containing primitive.
    -- Because it has the type 'GLExpr FragmentDomain Float', the addition
    -- below will be computed in a fragment shader.
    z :: GLExpr FragmentDomain Float
    z = frag x + 3

    -- \'time\' is a built-in I/O variable and as such it is computed on the CPU
    time :: GLExpr HostDomain Float

    -- We can use \'uniform\' to lift a host variable to an arbitrary domain
    -- Here 'uniform time' is inferred to have type 'GLExpr VertexDomain Float':
    yPlusTime :: GLExpr VertexDomain Float
    yPlusTime = y + uniform time

    -- Here 'uniform time' is inferred to be of type 'GLExpr FragmentDomain Float':
    zPlusTime :: GLExpr FragmentDomain Float
    zPlusTime = z + uniform time

    -- A generic floating-point vector of length 4
    v :: GLExpr d (Vec 4 Float)
    v = vec4 1 1 1 1

    -- A vector can be initialized from a numeric literal, so long as its
    -- underlying type 'Vec n t' is specified or can be inferred.
    -- Here is another way to define the same vector v:
    v' :: GLExpr d (Vec 4 Float)
    v' = 1

    -- Matrices are constructed from their columns:
    m :: GLExpr d (Mat 2 3 Float)
    m = mat2x3 (vec2 1 2) (vec2 3 4) (vec2 5 6)

    -- Operators like (.+) and (.*) act component-wise on vectors and matrices:
    _ = m .+ m .== mat2x3 (vec2 2 4) (vec2 6 8) (vec2 10 12)

    -- Non-boolean primitives and vectors over such types are instances of Num;
    -- in such cases Num methods like (+) can be used instead.
    _ = vec2 1 1 + 1 .== vec2 2 2

    -- The operator (.#) performs scalar multiplication:
    _ = 3 .# v
    _ = 3 .# m

    -- The operator (.\@) performs matrix multiplication
    -- (including matrix-vector multiplication):
    m1 :: GLExpr d (Mat 2 3 Float)
    m1 = ...
    m2 :: GLExpr d (Mat 3 4 Float)
    m2 = ...
    m1m2 :: GLExpr d (Mat 2 4 Float)
    m1m2 = m1 .\@ m2

    -- All multiplications here will take place in a vertex shader:
    m1m2v :: GLExpr VertexDomain (Vec 2 Float)
    m1m2v = m1m2 .\@ v

    -- The inferred type of m1m2 in this expression is 
    -- 'GLExpr HostDomain (Mat 2 4 Float)' so the multiplication of m1 and m2 
    -- will take place on the CPU.
    -- The inferred type of uniform m1m2 is 'GLExpr VertexDomain (Mat 2 4 Float)'
    -- and that of v is 'GLExpr VertexDomain (Vec 2 Float)' so their
    -- multiplication will take place in a vertex shader.
    m1m2v' :: GLExpr VertexDomain (Vec 2 Float)
    m1m2v' = uniform m1m2 .\@ v

@

`GLExpr`s can be used to construct `GLObj`s, which being instances
of 'Drawable' can be interpreted by a given 'Backend' using 'draw'.
For example:

@
-- initialize pos from the vertices of some 3D object
pos :: GLExpr VertexDomain (Vec 4 Float)
pos = vert [vec4 1 0 0 1, ...]

red :: GLExpr FragmentDomain (Vec 4 Float)
red = vec4 1 0 0 1

redObj :: GLObj
redObj = GLObj {
    primitiveMode = TriangleStrip,
    indices = Nothing,
    position = pos,
    color = red,
    discardWhen = False
}

-- or equivalently,
redObj' :: GLObj
redObj' = triangleStrip { position = pos, color = red }

-- we can now draw the object
main :: IO ()
main = draw GlutBackend redObj
@

A complete set of examples explained in more depth can be found in 
the ["Getting Started"](https://github.com/simeonkr/HaGL/blob/master/doc/Overview.md) guide.

-}

{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE UndecidableInstances #-}
{-# LANGUAGE TemplateHaskell #-}
{-# OPTIONS_GHC -dth-dec-file #-}
-- required due to use of genID
{-# OPTIONS_GHC -fno-full-laziness #-}

module Graphics.HaGL (
    -- * @GLType@
    -- | Any instance of 'GLType' can be the underlying type @t@ of a 'GLExpr'
    -- These types are:
    --
    --  * Primitive types: 'Float', 'Double', 'Int', 'UInt', 'Bool'
    --
    --  * Vectors: 'Vec' @n@ @Float@, 'Vec' @n@ @Double@, 'Vec' @n@ @Int@,
    --   'Vec' @n@ @UInt@, 'Vec' @n@ @Bool@
    --
    --  * Matrices: 'Mat' @p@ @q@ @Float@, 'Mat' @p@ @q@ @Double@
    --
    --  * Arrays: Represented as [t], where @t@ is a primitive type or a vector
    GLType,
    Float, Double, Int, UInt, Bool,
    Mat, Vec,
    GLElt,
    -- ** Raw vector/matrix constructors
    -- | Though raw types are not usually constructed directly, the following
    -- functions can be used for loading data from externally computed arrays 
    -- via [lifts](#lifts).
    fromMapping,
    fromList,
    -- ** Subclasses of @GLType@
    GLPrim, GLSingle, GLNumeric, GLSigned, GLFloating, GLSingleNumeric, GLInteger,
    GLPrimOrVec, GLInputType,
    GLSupportsSmoothInterp, GLSupportsBitwiseOps,
    -- * @GLExpr@
    -- | A HaGL expression can be created in one of the following ways:
    --
    --   * Using one of the HaGL-specific [constructors](#constructors)
    --
    --   * Directly from a numeric literal, if its underlying type @t@ is one of
    --    'Int', 'UInt', 'Float', 'Double', or a 'Vec' of one of these types. 
    --    (A vector initialized from a value @c@ is the vector with all elements 
    --    equal to c.)
    --
    --   * Through the application of [built-in operators and functions](#builtins)
    --
    GLExpr,
    GLDomain(..),
    ConstExpr,
    HostExpr,
    VertExpr,
    FragExpr,
    -- * Constructors #constructors#
    cnst,
    true,
    false,
    uniform,
    prec,
    vert,
    frag,
    noperspFrag,
    flatFrag,
    -- ** Vector, matrix, and array constructors
    -- | A constructor of the form vec/n/ creates a column vector with 
    -- /n/ components; a constructor of the form mat/p/x/q/ creates a matrix 
    -- with /p/ rows and /q/ columns (mat/p/ is an alias for mat/p/x/p/).  
    vec2, vec3, vec4,
    mat2, mat3, mat4,
    mat2x2, mat2x3, mat2x4,
    mat3x2, mat3x3, mat3x4,
    mat4x2, mat4x3, mat4x4,
    pre,
    app,
    ($-),
    array,
    -- * Deconstruction and indexing
    -- | To deconstruct a vector into a tuple of primitive elements or to
    -- deconstruct a matrix into a tuple of column vectors use 'decon'. This
    -- approach pairs particularly well with view patterns:
    --
    -- @
    -- vec2Flip :: GLExpr d (Vec 2 t) -> GLExpr d (Vec 2 t)
    -- vec2Flip (decon v2 -> (v1, v2)) = vec2 v2 v1
    -- @ 
    --
    -- Alternatively, with the synonyms @x@, @y@, @z@, @w@, referring to the 
    -- components of a vector in that order, projection functions consisting of 
    -- an ordered selection of such names followed by an underscore (e.g., 'xyz_'), 
    -- can be used to extract the corresponding components. For matrices, the 
    -- projection functions are of the form col/n/. Note that the types of these
    -- functions constrains the length of their input so that the operation is
    -- well-defined.
    Deconstructible(..),
    x_, y_, z_, w_,
    xy_, xz_, xw_,
    yx_, yz_, yw_,
    zx_, zy_, zw_,
    wx_, wy_, wz_,
    xyz_, xyw_, xzy_, xzw_, xwy_, xwz_,
    yxz_, yxw_, yzx_, yzw_, ywx_, ywz_,
    zxy_, zxw_, zyx_, zyw_, zwx_, zwy_,
    wxy_, wxz_, wyx_, wyz_, wzx_, wzy_,
    col0, col1, col2, col3,
    (.!),
    -- * Type conversion
    cast,
    matCast,
    -- * Built-in operators and functions #builtins#
    -- | Most definitions here strive to be consistent with the corresponding
    -- built-in functions provided by GLSL
    -- (cf. [The OpenGL Shading Language, Version 4.60.7]
    -- (https://registry.khronos.org/OpenGL/specs/gl/GLSLangSpec.4.60.pdf)), 
    -- in terms of semantics and typing constraints. Some notable exceptions 
    -- to this rule are:
    --
    --  * Typing restrictions may be stricter to prevent what would otherwise be
    --    runtime errors; for example, matrix multiplication is only defined on
    --    matrices with the correct dimensions.
    --
    --  * The operators @(+)@, @(-)@, @(*)@, as well as the function @negate@,
    --    being methods of @Num@, are only supported on expressions where the 
    --    underlying type is one of 'Int', 'UInt', 'Float', 'Double', or a 
    --    vector of one of these types.
    --    To perform these operations component-wise on matrices use the operators
    --    @(.+)@, @(.-)@, @(.*)@, or the function @neg@ respectively.
    --
    --  * The operator @(/)@ is only supported when the underlying type is
    --    'Float' or 'Double'. The more general operator @(./)@ additionally 
    --     supports integer and component-wise division.
    --
    --  * The operator @(.%)@ is the modulo operation on integers or
    --    integer-valued vectors.
    --
    --  * The operator @(.#)@ is used for scalar multiplication.
    --
    --  * The operator @(.\@)@ is used for matrix (including matrix-vector) multiplication.
    --
    --  * All boolean and bitwise operators are also prefixed with a single dot:
    --    @(.==)@, @(.<)@, @(.&&)@, @(.&)@, etc.

    -- ** Arithmetic operators
    (.+),
    (.-),
    (.*),
    (./),
    (.%),
    (.#),
    (.@),
    neg,
    -- ** Boolean operators and comparison functions
    (.<),
    (.<=),
    (.>),
    (.>=),
    (.==),
    (./=),
    (.&&),
    (.||),
    (.^^),
    nt,
    cond,
    -- ** Bitwise operators
    (.<<),
    (.>>),
    (.&),
    (.|),
    (.^),
    compl,
    -- ** Angle and trigonometry functions
    radians,
    degrees,
    Graphics.HaGL.sin,
    Graphics.HaGL.cos,
    Graphics.HaGL.tan,
    Graphics.HaGL.asin,
    Graphics.HaGL.acos,
    Graphics.HaGL.atan,
    Graphics.HaGL.sinh,
    Graphics.HaGL.cosh,
    Graphics.HaGL.tanh,
    Graphics.HaGL.asinh,
    Graphics.HaGL.acosh,
    Graphics.HaGL.atanh,
    -- ** Exponential functions
    pow,
    Graphics.HaGL.exp,
    Graphics.HaGL.log,
    exp2,
    log2,
    Graphics.HaGL.sqrt,
    inversesqrt,
    -- ** Common functions
    Graphics.HaGL.abs,
    sign,
    Graphics.HaGL.floor,
    trunc,
    Graphics.HaGL.round,
    roundEven,
    ceil,
    fract,
    Graphics.HaGL.mod,
    Graphics.HaGL.min,
    Graphics.HaGL.max,
    clamp,
    mix,
    step,
    smoothstep,
    -- ** Geometric functions
    Graphics.HaGL.length,
    distance,
    dot,
    cross,
    normalize,
    faceforward,
    reflect,
    refract,
    -- ** Matrix functions
    matrixCompMult,
    outerProduct,
    transpose,
    determinant,
    inverse,
    -- ** Vector relational functions
    lessThan,
    lessThanEqual,
    greaterThan,
    greaterThanEqual,
    equal,
    notEqual,
    Graphics.HaGL.any,
    Graphics.HaGL.all,
    Graphics.HaGL.not,
    -- * Custom function support
    -- | An n-ary @f@ function on @GLExpr@'s can be transported to an arbitrary
    -- domain using @glFunc/n/@. That is, @glFunc/n/ f@ will take in the same 
    -- arguments as f but will be evaluated in the domain of its return type 
    -- (in contrast to @f@, which being a native Haskell function, will always 
    -- be evaluated on the CPU).
    --
    -- However, due to the fact that GLSL does not allow recursion, attempting
    -- to call @glFunc/n/ f@, where @f@ is defined recursively (or mutually
    -- recursively in terms of other functions) will generally result in an
    -- exception being thrown. The one case where this is permissible is that of
    -- /tail-recursive/ functions of the form
    --
    -- @
    -- f x1 x2 ... = cond c b (f y1 y2 ...)
    -- @
    --
    -- where none of the expressions @c@, @b@, @y1@, @y2@, ... depend on @f@. Where
    -- applicable, such functions will be synthesized as GLSL loops. For example,
    -- the factorial function can be computed within a vertex shader as follows:
    --
    -- @
    -- fact = glFunc1 $ \\n -> fact' n 1 where
    --   fact' :: GLExpr VertexDomain Int -> GLExpr VertexDomain Int -> GLExpr VertexDomain Int
    --   fact' = glFunc2 $ \\n a -> cond (n .== 0) a (fact' (n - 1) (a * n))
    -- 
    -- x :: GLExpr VertexDomain Int
    -- x = fact 5
    -- @
    glFunc1,
    glFunc2,
    glFunc3,
    glFunc4,
    glFunc5,
    glFunc6,
    -- * Lifts from raw types #lifts#
    -- | If the need arises to use an n-ary native function @f@ that is not defined
    -- over @GLExpr@'s (for instance, to dynamically update array contents using
    -- functions defined on lists), such a function can be lifted to the
    -- @HostDomain@ using @glLift/n/@. @glLift/n/ f@ will then be defined over
    -- `HostExpr`s that agree with respective argument types of @f@. For example,
    -- the two expressions below compute the same array:
    --
    -- @
    -- a1 :: GLExpr HostDomain [Float]
    -- a1 = (glLift2 $ \\x y -> [x, y, x + y]) time time
    -- a2 :: GLExpr HostDomain [Float]
    -- a2 = array [time, 2 * time, 3 * time]
    -- @
    -- 
    glLift0, 
    glLift1, 
    glLift2,
    glLift3,
    glLift4,
    glLift5,
    glLift6,
    -- * Built-in I/O variables
    time,
    mouseLeft,
    mouseRight,
    mouseWheel,
    mouseX,
    mouseY,
    mousePos,
    -- * Drawables
    Drawable(..),
    GLObj(..),
    PrimitiveMode,
    points,
    Graphics.HaGL.lines,
    lineLoop,
    lineStrip,
    triangles,
    triangleStrip,
    triangleFan,
    quads,
    quadStrip,
    polygon,
    -- * Backends
    Backend(..),
    GlutOptions(..),
    GlutRunMode(..),
    drawGlut,
    drawGlutCustom,
    defaultGlutOptions,
) where

import GHC.TypeNats (KnownNat)
import qualified Graphics.Rendering.OpenGL as OpenGL

import Graphics.HaGL.TH.HaGL (gen2DCoordDecls, gen3DCoordDecls)
import Graphics.HaGL.Numerical (Mat, Vec, fromMapping, fromList)
import Graphics.HaGL.GLType
import Graphics.HaGL.GLExpr
import Graphics.HaGL.ExprID (genID)
import Graphics.HaGL.GLObj
import Graphics.HaGL.Eval
import Graphics.HaGL.Backend.GLUT


{-# NOINLINE mkExpr #-}
mkExpr :: (ExprID -> t -> t) -> t -> t
mkExpr ExprID -> t -> t
con t
e = ExprID -> t -> t
con (forall a. a -> ExprID
genID t
e) t
e


-- Instance declarations

instance GLPrim t => Enum (ConstExpr t) where
    toEnum :: Int -> ConstExpr t
toEnum Int
x = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLAtom d t -> GLExpr d t
GLAtom forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain). GLType t => t -> GLAtom d t
Const (forall a. Enum a => Int -> a
toEnum Int
x)
    fromEnum :: ConstExpr t -> Int
fromEnum = forall a. Enum a => a -> Int
fromEnum forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall t. GLExpr 'ConstDomain t -> t
constEval

instance {-# OVERLAPPING #-} (GLSigned (GLElt t), GLPrimOrVec t, Num t) => Num (GLExpr d t) where
    GLExpr d t
x + :: GLExpr d t -> GLExpr d t -> GLExpr d t
+ GLExpr d t
y = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain).
(GLNumeric (GLElt t), GLType t) =>
GLExpr d t -> GLExpr d t -> GLGenExpr d t
OpAdd GLExpr d t
x GLExpr d t
y
    GLExpr d t
x - :: GLExpr d t -> GLExpr d t -> GLExpr d t
- GLExpr d t
y = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain).
(GLNumeric (GLElt t), GLType t) =>
GLExpr d t -> GLExpr d t -> GLGenExpr d t
OpSubt GLExpr d t
x GLExpr d t
y
    GLExpr d t
x * :: GLExpr d t -> GLExpr d t -> GLExpr d t
* GLExpr d t
y = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain).
(GLNumeric (GLElt t), GLType t) =>
GLExpr d t -> GLExpr d t -> GLGenExpr d t
OpMult GLExpr d t
x GLExpr d t
y
    negate :: GLExpr d t -> GLExpr d t
negate GLExpr d t
x = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain).
(GLNumeric (GLElt t), GLType t) =>
GLExpr d t -> GLGenExpr d t
OpNeg GLExpr d t
x
    abs :: GLExpr d t -> GLExpr d t
abs GLExpr d t
x = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain).
(GLSigned (GLElt t), GLPrimOrVec t) =>
GLExpr d t -> GLGenExpr d t
Abs GLExpr d t
x
    signum :: GLExpr d t -> GLExpr d t
signum GLExpr d t
x = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain).
(GLSigned (GLElt t), GLPrimOrVec t) =>
GLExpr d t -> GLGenExpr d t
Sign GLExpr d t
x
    fromInteger :: Integer -> GLExpr d t
fromInteger Integer
x = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLAtom d t -> GLExpr d t
GLAtom forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain). GLType t => t -> GLAtom d t
Const (forall a. Num a => Integer -> a
fromInteger Integer
x)

-- Unsigned integers need to be handled separately as GLSL does not
-- support all the operations corresponding to those required for Num

instance {-# OVERLAPPING #-} Num (GLExpr d UInt) where
    GLExpr d UInt
x + :: GLExpr d UInt -> GLExpr d UInt -> GLExpr d UInt
+ GLExpr d UInt
y = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain).
(GLNumeric (GLElt t), GLType t) =>
GLExpr d t -> GLExpr d t -> GLGenExpr d t
OpAdd GLExpr d UInt
x GLExpr d UInt
y
    GLExpr d UInt
x - :: GLExpr d UInt -> GLExpr d UInt -> GLExpr d UInt
- GLExpr d UInt
y = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain).
(GLNumeric (GLElt t), GLType t) =>
GLExpr d t -> GLExpr d t -> GLGenExpr d t
OpSubt GLExpr d UInt
x GLExpr d UInt
y
    GLExpr d UInt
x * :: GLExpr d UInt -> GLExpr d UInt -> GLExpr d UInt
* GLExpr d UInt
y = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain).
(GLNumeric (GLElt t), GLType t) =>
GLExpr d t -> GLExpr d t -> GLGenExpr d t
OpMult GLExpr d UInt
x GLExpr d UInt
y
    negate :: GLExpr d UInt -> GLExpr d UInt
negate GLExpr d UInt
x = 
        forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t1 t (d :: GLDomain).
(GLPrim t1, GLPrim t) =>
GLExpr d t1 -> GLGenExpr d t
Cast forall a b. (a -> b) -> a -> b
$ 
            forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain).
(GLNumeric (GLElt t), GLType t) =>
GLExpr d t -> GLGenExpr d t
OpNeg
                (forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t1 t (d :: GLDomain).
(GLPrim t1, GLPrim t) =>
GLExpr d t1 -> GLGenExpr d t
Cast GLExpr d UInt
x :: GLExpr _ Int)
    abs :: GLExpr d UInt -> GLExpr d UInt
abs GLExpr d UInt
x = GLExpr d UInt
x
    signum :: GLExpr d UInt -> GLExpr d UInt
signum GLExpr d UInt
x = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t1 t (d :: GLDomain).
(GLPrim t1, GLPrim t) =>
GLExpr d t1 -> GLGenExpr d t
Cast 
        (forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t1 t (d :: GLDomain).
(GLPrim t1, GLPrim t) =>
GLExpr d t1 -> GLGenExpr d t
Cast GLExpr d UInt
x :: GLExpr _ Bool)
    fromInteger :: Integer -> GLExpr d UInt
fromInteger Integer
x = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLAtom d t -> GLExpr d t
GLAtom forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain). GLType t => t -> GLAtom d t
Const (forall a. Num a => Integer -> a
fromInteger Integer
x)

instance {-# OVERLAPPING #-} (GLType (Vec n UInt), GLType (Vec n Int), GLType (Vec n Bool), KnownNat n) => Num (GLExpr d (Vec n UInt)) where
    GLExpr d (Vec n UInt)
x + :: GLExpr d (Vec n UInt)
-> GLExpr d (Vec n UInt) -> GLExpr d (Vec n UInt)
+ GLExpr d (Vec n UInt)
y = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain).
(GLNumeric (GLElt t), GLType t) =>
GLExpr d t -> GLExpr d t -> GLGenExpr d t
OpAdd GLExpr d (Vec n UInt)
x GLExpr d (Vec n UInt)
y
    GLExpr d (Vec n UInt)
x - :: GLExpr d (Vec n UInt)
-> GLExpr d (Vec n UInt) -> GLExpr d (Vec n UInt)
- GLExpr d (Vec n UInt)
y = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain).
(GLNumeric (GLElt t), GLType t) =>
GLExpr d t -> GLExpr d t -> GLGenExpr d t
OpSubt GLExpr d (Vec n UInt)
x GLExpr d (Vec n UInt)
y
    GLExpr d (Vec n UInt)
x * :: GLExpr d (Vec n UInt)
-> GLExpr d (Vec n UInt) -> GLExpr d (Vec n UInt)
* GLExpr d (Vec n UInt)
y = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain).
(GLNumeric (GLElt t), GLType t) =>
GLExpr d t -> GLExpr d t -> GLGenExpr d t
OpMult GLExpr d (Vec n UInt)
x GLExpr d (Vec n UInt)
y
    negate :: GLExpr d (Vec n UInt) -> GLExpr d (Vec n UInt)
negate GLExpr d (Vec n UInt)
x =
        forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t1 t2 (p :: Nat) (q :: Nat) (d :: GLDomain).
(GLPrim t1, GLPrim t2, KnownNat p, KnownNat q) =>
GLExpr d (Mat p q t1) -> GLGenExpr d (Mat p q t2)
MatCast forall a b. (a -> b) -> a -> b
$ 
            forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain).
(GLNumeric (GLElt t), GLType t) =>
GLExpr d t -> GLGenExpr d t
OpNeg
                (forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t1 t2 (p :: Nat) (q :: Nat) (d :: GLDomain).
(GLPrim t1, GLPrim t2, KnownNat p, KnownNat q) =>
GLExpr d (Mat p q t1) -> GLGenExpr d (Mat p q t2)
MatCast GLExpr d (Vec n UInt)
x :: GLExpr _ (Vec _ Int))
    abs :: GLExpr d (Vec n UInt) -> GLExpr d (Vec n UInt)
abs GLExpr d (Vec n UInt)
x = GLExpr d (Vec n UInt)
x
    signum :: GLExpr d (Vec n UInt) -> GLExpr d (Vec n UInt)
signum GLExpr d (Vec n UInt)
x = 
        forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t1 t2 (p :: Nat) (q :: Nat) (d :: GLDomain).
(GLPrim t1, GLPrim t2, KnownNat p, KnownNat q) =>
GLExpr d (Mat p q t1) -> GLGenExpr d (Mat p q t2)
MatCast 
            (forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t1 t2 (p :: Nat) (q :: Nat) (d :: GLDomain).
(GLPrim t1, GLPrim t2, KnownNat p, KnownNat q) =>
GLExpr d (Mat p q t1) -> GLGenExpr d (Mat p q t2)
MatCast GLExpr d (Vec n UInt)
x :: GLExpr _ (Vec _ Bool))
    fromInteger :: Integer -> GLExpr d (Vec n UInt)
fromInteger Integer
x = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLAtom d t -> GLExpr d t
GLAtom forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain). GLType t => t -> GLAtom d t
Const (forall a. Num a => Integer -> a
fromInteger Integer
x)

instance (GLFloating (GLElt t), GLPrimOrVec t, Fractional t) => Fractional (GLExpr d t) where
    GLExpr d t
x / :: GLExpr d t -> GLExpr d t -> GLExpr d t
/ GLExpr d t
y = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain).
(GLNumeric (GLElt t), GLType t) =>
GLExpr d t -> GLExpr d t -> GLGenExpr d t
OpDiv GLExpr d t
x GLExpr d t
y
    fromRational :: Rational -> GLExpr d t
fromRational Rational
x = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLAtom d t -> GLExpr d t
GLAtom forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain). GLType t => t -> GLAtom d t
Const (forall a. Fractional a => Rational -> a
fromRational Rational
x)

instance (GLElt t ~ Float, GLPrimOrVec t, Fractional t) => Floating (GLExpr d t) where
    pi :: GLExpr d t
pi = GLExpr d t
3.141592653589793238
    sin :: GLExpr d t -> GLExpr d t
sin GLExpr d t
x = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain).
(GLElt t ~ Float, GLPrimOrVec t) =>
GLExpr d t -> GLGenExpr d t
Sin GLExpr d t
x
    cos :: GLExpr d t -> GLExpr d t
cos GLExpr d t
x = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain).
(GLElt t ~ Float, GLPrimOrVec t) =>
GLExpr d t -> GLGenExpr d t
Cos GLExpr d t
x
    tan :: GLExpr d t -> GLExpr d t
tan GLExpr d t
x = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain).
(GLElt t ~ Float, GLPrimOrVec t) =>
GLExpr d t -> GLGenExpr d t
Tan GLExpr d t
x
    asin :: GLExpr d t -> GLExpr d t
asin GLExpr d t
x = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain).
(GLElt t ~ Float, GLPrimOrVec t) =>
GLExpr d t -> GLGenExpr d t
Asin GLExpr d t
x
    acos :: GLExpr d t -> GLExpr d t
acos GLExpr d t
x = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain).
(GLElt t ~ Float, GLPrimOrVec t) =>
GLExpr d t -> GLGenExpr d t
Acos GLExpr d t
x
    atan :: GLExpr d t -> GLExpr d t
atan GLExpr d t
x = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain).
(GLElt t ~ Float, GLPrimOrVec t) =>
GLExpr d t -> GLGenExpr d t
Atan GLExpr d t
x
    sinh :: GLExpr d t -> GLExpr d t
sinh GLExpr d t
x = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain).
(GLElt t ~ Float, GLPrimOrVec t) =>
GLExpr d t -> GLGenExpr d t
Sinh GLExpr d t
x
    cosh :: GLExpr d t -> GLExpr d t
cosh GLExpr d t
x = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain).
(GLElt t ~ Float, GLPrimOrVec t) =>
GLExpr d t -> GLGenExpr d t
Cosh GLExpr d t
x
    tanh :: GLExpr d t -> GLExpr d t
tanh GLExpr d t
x = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain).
(GLElt t ~ Float, GLPrimOrVec t) =>
GLExpr d t -> GLGenExpr d t
Tanh GLExpr d t
x
    asinh :: GLExpr d t -> GLExpr d t
asinh GLExpr d t
x = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain).
(GLElt t ~ Float, GLPrimOrVec t) =>
GLExpr d t -> GLGenExpr d t
Asinh GLExpr d t
x
    acosh :: GLExpr d t -> GLExpr d t
acosh GLExpr d t
x = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain).
(GLElt t ~ Float, GLPrimOrVec t) =>
GLExpr d t -> GLGenExpr d t
Acosh GLExpr d t
x
    atanh :: GLExpr d t -> GLExpr d t
atanh GLExpr d t
x = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain).
(GLElt t ~ Float, GLPrimOrVec t) =>
GLExpr d t -> GLGenExpr d t
Atanh GLExpr d t
x
    GLExpr d t
x ** :: GLExpr d t -> GLExpr d t -> GLExpr d t
** GLExpr d t
y = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain).
(GLElt t ~ Float, GLPrimOrVec t) =>
GLExpr d t -> GLExpr d t -> GLGenExpr d t
Pow GLExpr d t
x GLExpr d t
y
    exp :: GLExpr d t -> GLExpr d t
exp GLExpr d t
x = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain).
(GLElt t ~ Float, GLPrimOrVec t) =>
GLExpr d t -> GLGenExpr d t
Exp GLExpr d t
x
    sqrt :: GLExpr d t -> GLExpr d t
sqrt GLExpr d t
x = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain).
(GLFloating (GLElt t), GLPrimOrVec t) =>
GLExpr d t -> GLGenExpr d t
Sqrt GLExpr d t
x
    log :: GLExpr d t -> GLExpr d t
log GLExpr d t
x = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain).
(GLElt t ~ Float, GLPrimOrVec t) =>
GLExpr d t -> GLGenExpr d t
Log GLExpr d t
x


-- * Constructors

-- | Construct a @GLExpr@ from a raw type. Rarely useful as this can
-- be done implicitly; e.g., from a numeric literal.
cnst :: GLType t => ConstExpr t -> GLExpr d t
cnst :: forall t (d :: GLDomain). GLType t => ConstExpr t -> GLExpr d t
cnst ConstExpr t
x = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLAtom d t -> GLExpr d t
GLAtom forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain). GLType t => t -> GLAtom d t
Const (forall t. GLExpr 'ConstDomain t -> t
constEval ConstExpr t
x)

true, false :: GLExpr d Bool
-- | The boolean value @true@
true :: forall (d :: GLDomain). GLExpr d Bool
true = forall t (d :: GLDomain). GLType t => ConstExpr t -> GLExpr d t
cnst forall a b. (a -> b) -> a -> b
$ forall a. Enum a => Int -> a
toEnum Int
1
-- | The boolean value @false@
false :: forall (d :: GLDomain). GLExpr d Bool
false = forall t (d :: GLDomain). GLType t => ConstExpr t -> GLExpr d t
cnst forall a b. (a -> b) -> a -> b
$ forall a. Enum a => Int -> a
toEnum Int
0

-- | Lift a `HostExpr` to an arbitrary @GLExpr@ whose value is the same across
-- any primitive processed in a shader, if used in the context of one
uniform :: GLType t => HostExpr t -> GLExpr d t
uniform :: forall t (d :: GLDomain). GLType t => HostExpr t -> GLExpr d t
uniform HostExpr t
x = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLAtom d t -> GLExpr d t
GLAtom forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain).
GLType t =>
GLExpr 'HostDomain t -> GLAtom d t
Uniform HostExpr t
x

-- | @prec x0 x@ is used to obtain a reference to the value @x@ one "time-step"
-- in the past, or @x0@ at the zero-th point in time. The @prec@ operator is 
-- usually used to define expressions recurrently; for example:
-- @let x = prec 0 (x + 1)@ counts the total number of points in time. The
-- interpretation of a time-step in a given backend is normally an interval
-- that is on average equal to the length of time between two redraws.
prec :: GLType t => HostExpr t -> HostExpr t -> HostExpr t
prec :: forall t. GLType t => HostExpr t -> HostExpr t -> HostExpr t
prec HostExpr t
x0 HostExpr t
x = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLAtom d t -> GLExpr d t
GLAtom forall a b. (a -> b) -> a -> b
$ forall t.
GLType t =>
GLExpr 'HostDomain t
-> GLExpr 'HostDomain t -> GLAtom 'HostDomain t
IOPrec HostExpr t
x0 HostExpr t
x


-- | A vertex input variable (attribute) constructed from a stream of per-vertex 
-- data. The number of vertices (the length of the stream) should be consistent
-- across all vertex attributes used to construct a given @GLObj@.
vert :: GLInputType t => [ConstExpr t] -> VertExpr t
vert :: forall t. GLInputType t => [ConstExpr t] -> VertExpr t
vert [ConstExpr t]
inp = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLAtom d t -> GLExpr d t
GLAtom forall a b. (a -> b) -> a -> b
$ forall t.
GLInputType t =>
[GLExpr 'ConstDomain t] -> GLAtom 'VertexDomain t
Inp [ConstExpr t]
inp

-- | A fragment input variable constructed from the output data of a vertex 
-- variable, interpolated in a perspective-correct manner over the primitive
-- being processed
frag :: GLSupportsSmoothInterp t => VertExpr t -> FragExpr t
frag :: forall t. GLSupportsSmoothInterp t => VertExpr t -> FragExpr t
frag VertExpr t
x = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLAtom d t -> GLExpr d t
GLAtom forall a b. (a -> b) -> a -> b
$ forall t.
GLInputType t =>
InterpolationType
-> GLExpr 'VertexDomain t -> GLAtom 'FragmentDomain t
Frag InterpolationType
Smooth VertExpr t
x

-- | A fragment input variable constructed from the output data of a vertex 
-- variable, interpolated linearly across the primitive being processed
noperspFrag :: GLSupportsSmoothInterp t => GLInputType t => VertExpr t -> FragExpr t
noperspFrag :: forall t.
(GLSupportsSmoothInterp t, GLInputType t) =>
VertExpr t -> FragExpr t
noperspFrag VertExpr t
x = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLAtom d t -> GLExpr d t
GLAtom forall a b. (a -> b) -> a -> b
$ forall t.
GLInputType t =>
InterpolationType
-> GLExpr 'VertexDomain t -> GLAtom 'FragmentDomain t
Frag InterpolationType
NoPerspective VertExpr t
x

-- | A fragment input variable constructed from the output data of a vertex
-- variable, having the same value across the primitive being processed
-- (cf. the OpenGL API for which vertex is used to determine its value)
flatFrag :: GLInputType t => VertExpr t -> FragExpr t
flatFrag :: forall t. GLInputType t => VertExpr t -> FragExpr t
flatFrag VertExpr t
x = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLAtom d t -> GLExpr d t
GLAtom forall a b. (a -> b) -> a -> b
$ forall t.
GLInputType t =>
InterpolationType
-> GLExpr 'VertexDomain t -> GLAtom 'FragmentDomain t
Frag InterpolationType
Flat VertExpr t
x


-- * Vector, matrix, and array constructors

vec2 :: GLExpr d t1 -> GLExpr d t1 -> GLExpr d (Mat 2 1 t1)
vec2 GLExpr d t1
x GLExpr d t1
y = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t1 (d :: GLDomain).
GLType (Vec 2 t1) =>
GLExpr d t1 -> GLExpr d t1 -> GLGenExpr d (Vec 2 t1)
GLVec2 GLExpr d t1
x GLExpr d t1
y
vec3 :: GLExpr d t1 -> GLExpr d t1 -> GLExpr d t1 -> GLExpr d (Mat 3 1 t1)
vec3 GLExpr d t1
x GLExpr d t1
y GLExpr d t1
z = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t1 (d :: GLDomain).
GLType (Vec 3 t1) =>
GLExpr d t1 -> GLExpr d t1 -> GLExpr d t1 -> GLGenExpr d (Vec 3 t1)
GLVec3 GLExpr d t1
x GLExpr d t1
y GLExpr d t1
z
vec4 :: GLExpr d t1
-> GLExpr d t1
-> GLExpr d t1
-> GLExpr d t1
-> GLExpr d (Mat 4 1 t1)
vec4 GLExpr d t1
x GLExpr d t1
y GLExpr d t1
z GLExpr d t1
w = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t1 (d :: GLDomain).
GLType (Vec 4 t1) =>
GLExpr d t1
-> GLExpr d t1
-> GLExpr d t1
-> GLExpr d t1
-> GLGenExpr d (Vec 4 t1)
GLVec4 GLExpr d t1
x GLExpr d t1
y GLExpr d t1
z GLExpr d t1
w
mat2 :: GLExpr d (Vec 2 t1) -> GLExpr d (Vec 2 t1) -> GLExpr d (Mat 2 2 t1)
mat2 GLExpr d (Vec 2 t1)
x GLExpr d (Vec 2 t1)
y = forall {t1} {d :: GLDomain}.
(GLFloating t1, GLType (Vec 2 t1), GLType (Mat 2 2 t1)) =>
GLExpr d (Vec 2 t1) -> GLExpr d (Vec 2 t1) -> GLExpr d (Mat 2 2 t1)
mat2x2 GLExpr d (Vec 2 t1)
x GLExpr d (Vec 2 t1)
y
mat3 :: GLExpr d (Vec 3 t1)
-> GLExpr d (Vec 3 t1)
-> GLExpr d (Vec 3 t1)
-> GLExpr d (Mat 3 3 t1)
mat3 GLExpr d (Vec 3 t1)
x GLExpr d (Vec 3 t1)
y GLExpr d (Vec 3 t1)
z = forall {t1} {d :: GLDomain}.
(GLFloating t1, GLType (Vec 3 t1), GLType (Mat 3 3 t1)) =>
GLExpr d (Vec 3 t1)
-> GLExpr d (Vec 3 t1)
-> GLExpr d (Vec 3 t1)
-> GLExpr d (Mat 3 3 t1)
mat3x3 GLExpr d (Vec 3 t1)
x GLExpr d (Vec 3 t1)
y GLExpr d (Vec 3 t1)
z
mat4 :: GLExpr d (Vec 4 t1)
-> GLExpr d (Vec 4 t1)
-> GLExpr d (Vec 4 t1)
-> GLExpr d (Vec 4 t1)
-> GLExpr d (Mat 4 4 t1)
mat4 GLExpr d (Vec 4 t1)
x GLExpr d (Vec 4 t1)
y GLExpr d (Vec 4 t1)
z GLExpr d (Vec 4 t1)
w = forall {t1} {d :: GLDomain}.
(GLFloating t1, GLType (Vec 4 t1), GLType (Mat 4 4 t1)) =>
GLExpr d (Vec 4 t1)
-> GLExpr d (Vec 4 t1)
-> GLExpr d (Vec 4 t1)
-> GLExpr d (Vec 4 t1)
-> GLExpr d (Mat 4 4 t1)
mat4x4 GLExpr d (Vec 4 t1)
x GLExpr d (Vec 4 t1)
y GLExpr d (Vec 4 t1)
z GLExpr d (Vec 4 t1)
w
mat2x2 :: GLExpr d (Vec 2 t1) -> GLExpr d (Vec 2 t1) -> GLExpr d (Mat 2 2 t1)
mat2x2 GLExpr d (Vec 2 t1)
x GLExpr d (Vec 2 t1)
y = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t1 (d :: GLDomain).
(GLFloating t1, GLType (Vec 2 t1), GLType (Mat 2 2 t1)) =>
GLExpr d (Vec 2 t1)
-> GLExpr d (Vec 2 t1) -> GLGenExpr d (Mat 2 2 t1)
GLMat2x2 GLExpr d (Vec 2 t1)
x GLExpr d (Vec 2 t1)
y
mat2x3 :: GLExpr d (Vec 2 t1)
-> GLExpr d (Vec 2 t1)
-> GLExpr d (Vec 2 t1)
-> GLExpr d (Mat 2 3 t1)
mat2x3 GLExpr d (Vec 2 t1)
x GLExpr d (Vec 2 t1)
y GLExpr d (Vec 2 t1)
z = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t1 (d :: GLDomain).
(GLFloating t1, GLType (Vec 2 t1), GLType (Mat 2 3 t1)) =>
GLExpr d (Vec 2 t1)
-> GLExpr d (Vec 2 t1)
-> GLExpr d (Vec 2 t1)
-> GLGenExpr d (Mat 2 3 t1)
GLMat2x3 GLExpr d (Vec 2 t1)
x GLExpr d (Vec 2 t1)
y GLExpr d (Vec 2 t1)
z
mat2x4 :: GLExpr d (Vec 2 t1)
-> GLExpr d (Vec 2 t1)
-> GLExpr d (Vec 2 t1)
-> GLExpr d (Vec 2 t1)
-> GLExpr d (Mat 2 4 t1)
mat2x4 GLExpr d (Vec 2 t1)
x GLExpr d (Vec 2 t1)
y GLExpr d (Vec 2 t1)
z GLExpr d (Vec 2 t1)
w = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t1 (d :: GLDomain).
(GLFloating t1, GLType (Vec 2 t1), GLType (Mat 2 4 t1)) =>
GLExpr d (Vec 2 t1)
-> GLExpr d (Vec 2 t1)
-> GLExpr d (Vec 2 t1)
-> GLExpr d (Vec 2 t1)
-> GLGenExpr d (Mat 2 4 t1)
GLMat2x4 GLExpr d (Vec 2 t1)
x GLExpr d (Vec 2 t1)
y GLExpr d (Vec 2 t1)
z GLExpr d (Vec 2 t1)
w
mat3x2 :: GLExpr d (Vec 3 t1) -> GLExpr d (Vec 3 t1) -> GLExpr d (Mat 3 2 t1)
mat3x2 GLExpr d (Vec 3 t1)
x GLExpr d (Vec 3 t1)
y = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t1 (d :: GLDomain).
(GLFloating t1, GLType (Vec 3 t1), GLType (Mat 3 2 t1)) =>
GLExpr d (Vec 3 t1)
-> GLExpr d (Vec 3 t1) -> GLGenExpr d (Mat 3 2 t1)
GLMat3x2 GLExpr d (Vec 3 t1)
x GLExpr d (Vec 3 t1)
y
mat3x3 :: GLExpr d (Vec 3 t1)
-> GLExpr d (Vec 3 t1)
-> GLExpr d (Vec 3 t1)
-> GLExpr d (Mat 3 3 t1)
mat3x3 GLExpr d (Vec 3 t1)
x GLExpr d (Vec 3 t1)
y GLExpr d (Vec 3 t1)
z = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t1 (d :: GLDomain).
(GLFloating t1, GLType (Vec 3 t1), GLType (Mat 3 3 t1)) =>
GLExpr d (Vec 3 t1)
-> GLExpr d (Vec 3 t1)
-> GLExpr d (Vec 3 t1)
-> GLGenExpr d (Mat 3 3 t1)
GLMat3x3 GLExpr d (Vec 3 t1)
x GLExpr d (Vec 3 t1)
y GLExpr d (Vec 3 t1)
z
mat3x4 :: GLExpr d (Vec 3 t1)
-> GLExpr d (Vec 3 t1)
-> GLExpr d (Vec 3 t1)
-> GLExpr d (Vec 3 t1)
-> GLExpr d (Mat 3 4 t1)
mat3x4 GLExpr d (Vec 3 t1)
x GLExpr d (Vec 3 t1)
y GLExpr d (Vec 3 t1)
z GLExpr d (Vec 3 t1)
w = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t1 (d :: GLDomain).
(GLFloating t1, GLType (Vec 3 t1), GLType (Mat 3 4 t1)) =>
GLExpr d (Vec 3 t1)
-> GLExpr d (Vec 3 t1)
-> GLExpr d (Vec 3 t1)
-> GLExpr d (Vec 3 t1)
-> GLGenExpr d (Mat 3 4 t1)
GLMat3x4 GLExpr d (Vec 3 t1)
x GLExpr d (Vec 3 t1)
y GLExpr d (Vec 3 t1)
z GLExpr d (Vec 3 t1)
w
mat4x2 :: GLExpr d (Vec 4 t1) -> GLExpr d (Vec 4 t1) -> GLExpr d (Mat 4 2 t1)
mat4x2 GLExpr d (Vec 4 t1)
x GLExpr d (Vec 4 t1)
y = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t1 (d :: GLDomain).
(GLFloating t1, GLType (Vec 4 t1), GLType (Mat 4 2 t1)) =>
GLExpr d (Vec 4 t1)
-> GLExpr d (Vec 4 t1) -> GLGenExpr d (Mat 4 2 t1)
GLMat4x2 GLExpr d (Vec 4 t1)
x GLExpr d (Vec 4 t1)
y
mat4x3 :: GLExpr d (Vec 4 t1)
-> GLExpr d (Vec 4 t1)
-> GLExpr d (Vec 4 t1)
-> GLExpr d (Mat 4 3 t1)
mat4x3 GLExpr d (Vec 4 t1)
x GLExpr d (Vec 4 t1)
y GLExpr d (Vec 4 t1)
z = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t1 (d :: GLDomain).
(GLFloating t1, GLType (Vec 4 t1), GLType (Mat 4 3 t1)) =>
GLExpr d (Vec 4 t1)
-> GLExpr d (Vec 4 t1)
-> GLExpr d (Vec 4 t1)
-> GLGenExpr d (Mat 4 3 t1)
GLMat4x3 GLExpr d (Vec 4 t1)
x GLExpr d (Vec 4 t1)
y GLExpr d (Vec 4 t1)
z
mat4x4 :: GLExpr d (Vec 4 t1)
-> GLExpr d (Vec 4 t1)
-> GLExpr d (Vec 4 t1)
-> GLExpr d (Vec 4 t1)
-> GLExpr d (Mat 4 4 t1)
mat4x4 GLExpr d (Vec 4 t1)
x GLExpr d (Vec 4 t1)
y GLExpr d (Vec 4 t1)
z GLExpr d (Vec 4 t1)
w = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t1 (d :: GLDomain).
(GLFloating t1, GLType (Vec 4 t1), GLType (Mat 4 4 t1)) =>
GLExpr d (Vec 4 t1)
-> GLExpr d (Vec 4 t1)
-> GLExpr d (Vec 4 t1)
-> GLExpr d (Vec 4 t1)
-> GLGenExpr d (Mat 4 4 t1)
GLMat4x4 GLExpr d (Vec 4 t1)
x GLExpr d (Vec 4 t1)
y GLExpr d (Vec 4 t1)
z GLExpr d (Vec 4 t1)
w

-- | Extend a vector by prepending an element
pre :: GLExpr d t1 -> GLExpr d (Vec n t1) -> GLExpr d (Mat (n + 1) 1 t1)
pre GLExpr d t1
x GLExpr d (Vec n t1)
y = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall (n :: Nat) t1 (d :: GLDomain).
(GLType (Vec n t1), GLType (Vec (n + 1) t1)) =>
GLExpr d t1 -> GLExpr d (Vec n t1) -> GLGenExpr d (Vec (n + 1) t1)
Pre GLExpr d t1
x GLExpr d (Vec n t1)
y
-- | Extend a vector by appending an element
app :: GLExpr d (Vec n t1) -> GLExpr d t1 -> GLExpr d (Mat (n + 1) 1 t1)
app GLExpr d (Vec n t1)
x GLExpr d t1
y = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall (n :: Nat) t1 (d :: GLDomain).
(GLType (Vec n t1), GLType t1, GLType (Vec (n + 1) t1)) =>
GLExpr d (Vec n t1) -> GLExpr d t1 -> GLGenExpr d (Vec (n + 1) t1)
App GLExpr d (Vec n t1)
x GLExpr d t1
y

infixr 8 $-

-- | Concatenate two vectors together
GLExpr d (Vec m t1)
x $- :: GLExpr d (Vec m t1)
-> GLExpr d (Vec n t1) -> GLExpr d (Mat (m + n) 1 t1)
$- GLExpr d (Vec n t1)
y = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall (m :: Nat) t1 (n :: Nat) (d :: GLDomain).
(GLType (Vec m t1), GLType (Vec n t1), GLType (Vec (m + n) t1)) =>
GLExpr d (Vec m t1)
-> GLExpr d (Vec n t1) -> GLGenExpr d (Vec (m + n) t1)
Conc GLExpr d (Vec m t1)
x GLExpr d (Vec n t1)
y

-- | Create an array from a list of 'HostExpr's
array :: [GLExpr 'HostDomain t1] -> GLExpr 'HostDomain [t1]
array [GLExpr 'HostDomain t1]
xs = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t1.
GLType [t1] =>
[GLExpr 'HostDomain t1] -> GLGenExpr 'HostDomain [t1]
GLArray [GLExpr 'HostDomain t1]
xs


-- * Deconstruction and indexing

x_ :: GLExpr d (Vec n t) -> GLExpr d t
x_ GLExpr d (Vec n t)
v = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall (n :: Nat) t (m :: Nat) (d :: GLDomain).
(GLType (Vec n t), m <= n) =>
GLCoord m -> GLExpr d (Vec n t) -> GLGenExpr d t
OpCoord GLCoord 1
CoordX GLExpr d (Vec n t)
v
y_ :: GLExpr d (Vec n t) -> GLExpr d t
y_ GLExpr d (Vec n t)
v = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall (n :: Nat) t (m :: Nat) (d :: GLDomain).
(GLType (Vec n t), m <= n) =>
GLCoord m -> GLExpr d (Vec n t) -> GLGenExpr d t
OpCoord GLCoord 2
CoordY GLExpr d (Vec n t)
v
z_ :: GLExpr d (Vec n t) -> GLExpr d t
z_ GLExpr d (Vec n t)
v = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall (n :: Nat) t (m :: Nat) (d :: GLDomain).
(GLType (Vec n t), m <= n) =>
GLCoord m -> GLExpr d (Vec n t) -> GLGenExpr d t
OpCoord GLCoord 3
CoordZ GLExpr d (Vec n t)
v
w_ :: GLExpr d (Vec n t) -> GLExpr d t
w_ GLExpr d (Vec n t)
v = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall (n :: Nat) t (m :: Nat) (d :: GLDomain).
(GLType (Vec n t), m <= n) =>
GLCoord m -> GLExpr d (Vec n t) -> GLGenExpr d t
OpCoord GLCoord 4
CoordW GLExpr d (Vec n t)
v
$GLExpr d (Vec n t1) -> GLExpr d (Mat (1 + 1) 1 t1)
GLExpr d (Vec n t1) -> GLExpr d (Mat (1 + 1) 1 t1)
GLExpr d (Vec n t1) -> GLExpr d (Mat (1 + 1) 1 t1)
GLExpr d (Vec n t1) -> GLExpr d (Mat (1 + 1) 1 t1)
GLExpr d (Vec n t1) -> GLExpr d (Mat (1 + 1) 1 t1)
GLExpr d (Vec n t1) -> GLExpr d (Mat (1 + 1) 1 t1)
GLExpr d (Vec n t1) -> GLExpr d (Mat (1 + 1) 1 t1)
GLExpr d (Vec n t1) -> GLExpr d (Mat (1 + 1) 1 t1)
GLExpr d (Vec n t1) -> GLExpr d (Mat (1 + 1) 1 t1)
GLExpr d (Vec n t1) -> GLExpr d (Mat (1 + 1) 1 t1)
GLExpr d (Vec n t1) -> GLExpr d (Mat (1 + 1) 1 t1)
GLExpr d (Vec n t1) -> GLExpr d (Mat (1 + 1) 1 t1)
wz_ :: GLExpr d (Vec n t1) -> GLExpr d (Mat (1 + 1) 1 t1)
wy_ :: GLExpr d (Vec n t1) -> GLExpr d (Mat (1 + 1) 1 t1)
wx_ :: GLExpr d (Vec n t1) -> GLExpr d (Mat (1 + 1) 1 t1)
zw_ :: GLExpr d (Vec n t1) -> GLExpr d (Mat (1 + 1) 1 t1)
zy_ :: GLExpr d (Vec n t1) -> GLExpr d (Mat (1 + 1) 1 t1)
zx_ :: GLExpr d (Vec n t1) -> GLExpr d (Mat (1 + 1) 1 t1)
yw_ :: GLExpr d (Vec n t1) -> GLExpr d (Mat (1 + 1) 1 t1)
yz_ :: GLExpr d (Vec n t1) -> GLExpr d (Mat (1 + 1) 1 t1)
yx_ :: GLExpr d (Vec n t1) -> GLExpr d (Mat (1 + 1) 1 t1)
xw_ :: GLExpr d (Vec n t1) -> GLExpr d (Mat (1 + 1) 1 t1)
xz_ :: GLExpr d (Vec n t1) -> GLExpr d (Mat (1 + 1) 1 t1)
xy_ :: GLExpr d (Vec n t1) -> GLExpr d (Mat (1 + 1) 1 t1)
gen2DCoordDecls
$GLExpr d (Vec n t1) -> GLExpr d (Mat ((1 + 1) + 1) 1 t1)
GLExpr d (Vec n t1) -> GLExpr d (Mat ((1 + 1) + 1) 1 t1)
GLExpr d (Vec n t1) -> GLExpr d (Mat ((1 + 1) + 1) 1 t1)
GLExpr d (Vec n t1) -> GLExpr d (Mat ((1 + 1) + 1) 1 t1)
GLExpr d (Vec n t1) -> GLExpr d (Mat ((1 + 1) + 1) 1 t1)
GLExpr d (Vec n t1) -> GLExpr d (Mat ((1 + 1) + 1) 1 t1)
GLExpr d (Vec n t1) -> GLExpr d (Mat ((1 + 1) + 1) 1 t1)
GLExpr d (Vec n t1) -> GLExpr d (Mat ((1 + 1) + 1) 1 t1)
GLExpr d (Vec n t1) -> GLExpr d (Mat ((1 + 1) + 1) 1 t1)
GLExpr d (Vec n t1) -> GLExpr d (Mat ((1 + 1) + 1) 1 t1)
GLExpr d (Vec n t1) -> GLExpr d (Mat ((1 + 1) + 1) 1 t1)
GLExpr d (Vec n t1) -> GLExpr d (Mat ((1 + 1) + 1) 1 t1)
GLExpr d (Vec n t1) -> GLExpr d (Mat ((1 + 1) + 1) 1 t1)
GLExpr d (Vec n t1) -> GLExpr d (Mat ((1 + 1) + 1) 1 t1)
GLExpr d (Vec n t1) -> GLExpr d (Mat ((1 + 1) + 1) 1 t1)
GLExpr d (Vec n t1) -> GLExpr d (Mat ((1 + 1) + 1) 1 t1)
GLExpr d (Vec n t1) -> GLExpr d (Mat ((1 + 1) + 1) 1 t1)
GLExpr d (Vec n t1) -> GLExpr d (Mat ((1 + 1) + 1) 1 t1)
GLExpr d (Vec n t1) -> GLExpr d (Mat ((1 + 1) + 1) 1 t1)
GLExpr d (Vec n t1) -> GLExpr d (Mat ((1 + 1) + 1) 1 t1)
GLExpr d (Vec n t1) -> GLExpr d (Mat ((1 + 1) + 1) 1 t1)
GLExpr d (Vec n t1) -> GLExpr d (Mat ((1 + 1) + 1) 1 t1)
GLExpr d (Vec n t1) -> GLExpr d (Mat ((1 + 1) + 1) 1 t1)
GLExpr d (Vec n t1) -> GLExpr d (Mat ((1 + 1) + 1) 1 t1)
wzy_ :: GLExpr d (Vec n t1) -> GLExpr d (Mat ((1 + 1) + 1) 1 t1)
wzx_ :: GLExpr d (Vec n t1) -> GLExpr d (Mat ((1 + 1) + 1) 1 t1)
wyz_ :: GLExpr d (Vec n t1) -> GLExpr d (Mat ((1 + 1) + 1) 1 t1)
wyx_ :: GLExpr d (Vec n t1) -> GLExpr d (Mat ((1 + 1) + 1) 1 t1)
wxz_ :: GLExpr d (Vec n t1) -> GLExpr d (Mat ((1 + 1) + 1) 1 t1)
wxy_ :: GLExpr d (Vec n t1) -> GLExpr d (Mat ((1 + 1) + 1) 1 t1)
zwy_ :: GLExpr d (Vec n t1) -> GLExpr d (Mat ((1 + 1) + 1) 1 t1)
zwx_ :: GLExpr d (Vec n t1) -> GLExpr d (Mat ((1 + 1) + 1) 1 t1)
zyw_ :: GLExpr d (Vec n t1) -> GLExpr d (Mat ((1 + 1) + 1) 1 t1)
zyx_ :: GLExpr d (Vec n t1) -> GLExpr d (Mat ((1 + 1) + 1) 1 t1)
zxw_ :: GLExpr d (Vec n t1) -> GLExpr d (Mat ((1 + 1) + 1) 1 t1)
zxy_ :: GLExpr d (Vec n t1) -> GLExpr d (Mat ((1 + 1) + 1) 1 t1)
ywz_ :: GLExpr d (Vec n t1) -> GLExpr d (Mat ((1 + 1) + 1) 1 t1)
ywx_ :: GLExpr d (Vec n t1) -> GLExpr d (Mat ((1 + 1) + 1) 1 t1)
yzw_ :: GLExpr d (Vec n t1) -> GLExpr d (Mat ((1 + 1) + 1) 1 t1)
yzx_ :: GLExpr d (Vec n t1) -> GLExpr d (Mat ((1 + 1) + 1) 1 t1)
yxw_ :: GLExpr d (Vec n t1) -> GLExpr d (Mat ((1 + 1) + 1) 1 t1)
yxz_ :: GLExpr d (Vec n t1) -> GLExpr d (Mat ((1 + 1) + 1) 1 t1)
xwz_ :: GLExpr d (Vec n t1) -> GLExpr d (Mat ((1 + 1) + 1) 1 t1)
xwy_ :: GLExpr d (Vec n t1) -> GLExpr d (Mat ((1 + 1) + 1) 1 t1)
xzw_ :: GLExpr d (Vec n t1) -> GLExpr d (Mat ((1 + 1) + 1) 1 t1)
xzy_ :: GLExpr d (Vec n t1) -> GLExpr d (Mat ((1 + 1) + 1) 1 t1)
xyw_ :: GLExpr d (Vec n t1) -> GLExpr d (Mat ((1 + 1) + 1) 1 t1)
xyz_ :: GLExpr d (Vec n t1) -> GLExpr d (Mat ((1 + 1) + 1) 1 t1)
gen3DCoordDecls

-- | The first column of a matrix
col0 :: GLExpr d (Mat r c t1) -> GLExpr d (Mat r 1 t1)
col0 GLExpr d (Mat r c t1)
m = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall (r :: Nat) (c :: Nat) t1 (m :: Nat) (d :: GLDomain).
(GLType (Mat r c t1), GLType (Vec r t1), (m + 1) <= c) =>
GLCol m -> GLExpr d (Mat r c t1) -> GLGenExpr d (Vec r t1)
OpCol GLCol 0
Col0 GLExpr d (Mat r c t1)
m
-- | The second column of a matrix
col1 :: GLExpr d (Mat r c t1) -> GLExpr d (Mat r 1 t1)
col1 GLExpr d (Mat r c t1)
m = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall (r :: Nat) (c :: Nat) t1 (m :: Nat) (d :: GLDomain).
(GLType (Mat r c t1), GLType (Vec r t1), (m + 1) <= c) =>
GLCol m -> GLExpr d (Mat r c t1) -> GLGenExpr d (Vec r t1)
OpCol GLCol 1
Col1 GLExpr d (Mat r c t1)
m
-- | The third column of a matrix
col2 :: GLExpr d (Mat r c t1) -> GLExpr d (Mat r 1 t1)
col2 GLExpr d (Mat r c t1)
m = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall (r :: Nat) (c :: Nat) t1 (m :: Nat) (d :: GLDomain).
(GLType (Mat r c t1), GLType (Vec r t1), (m + 1) <= c) =>
GLCol m -> GLExpr d (Mat r c t1) -> GLGenExpr d (Vec r t1)
OpCol GLCol 2
Col2 GLExpr d (Mat r c t1)
m
-- | The fourth column of a matrix
col3 :: GLExpr d (Mat r c t1) -> GLExpr d (Mat r 1 t1)
col3 GLExpr d (Mat r c t1)
m = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall (r :: Nat) (c :: Nat) t1 (m :: Nat) (d :: GLDomain).
(GLType (Mat r c t1), GLType (Vec r t1), (m + 1) <= c) =>
GLCol m -> GLExpr d (Mat r c t1) -> GLGenExpr d (Vec r t1)
OpCol GLCol 3
Col3 GLExpr d (Mat r c t1)
m

-- | Array index operator, returning the @i@-th (0-indexed) element of the array
GLExpr d [t]
arr .! :: GLExpr d [t] -> GLExpr d Int -> GLExpr d t
.! GLExpr d Int
i = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain).
(GLType [t], GLType t) =>
GLExpr d [t] -> GLExpr d Int -> GLGenExpr d t
OpArrayElt GLExpr d [t]
arr GLExpr d Int
i

-- | An expression that can be deconstructed into its components
class Deconstructible t where
    -- | The resulting type of the deconstruction
    type Decon t
    -- | Deconstruct the given expression
    decon :: t -> Decon t

instance (GLPrim t, GLType (Vec 2 t)) => Deconstructible (GLExpr d (Vec 2 t)) where
    type Decon (GLExpr d (Vec 2 t)) = (GLExpr d t, GLExpr d t) 
    decon :: GLExpr d (Vec 2 t) -> Decon (GLExpr d (Vec 2 t))
decon GLExpr d (Vec 2 t)
v = (forall {n :: Nat} {t} {d :: GLDomain}.
(OrdCond (CmpNat 1 n) 'True 'True 'False ~ 'True, GLType t,
 GLType (Vec n t)) =>
GLExpr d (Vec n t) -> GLExpr d t
x_ GLExpr d (Vec 2 t)
v, forall {n :: Nat} {t} {d :: GLDomain}.
(OrdCond (CmpNat 2 n) 'True 'True 'False ~ 'True, GLType t,
 GLType (Vec n t)) =>
GLExpr d (Vec n t) -> GLExpr d t
y_ GLExpr d (Vec 2 t)
v)
instance (GLPrim t, GLType (Vec 3 t)) => Deconstructible (GLExpr d (Vec 3 t)) where
    type Decon (GLExpr d (Vec 3 t)) = (GLExpr d t, GLExpr d t, GLExpr d t) 
    decon :: GLExpr d (Vec 3 t) -> Decon (GLExpr d (Vec 3 t))
decon GLExpr d (Vec 3 t)
v = (forall {n :: Nat} {t} {d :: GLDomain}.
(OrdCond (CmpNat 1 n) 'True 'True 'False ~ 'True, GLType t,
 GLType (Vec n t)) =>
GLExpr d (Vec n t) -> GLExpr d t
x_ GLExpr d (Vec 3 t)
v, forall {n :: Nat} {t} {d :: GLDomain}.
(OrdCond (CmpNat 2 n) 'True 'True 'False ~ 'True, GLType t,
 GLType (Vec n t)) =>
GLExpr d (Vec n t) -> GLExpr d t
y_ GLExpr d (Vec 3 t)
v, forall {n :: Nat} {t} {d :: GLDomain}.
(OrdCond (CmpNat 3 n) 'True 'True 'False ~ 'True, GLType t,
 GLType (Vec n t)) =>
GLExpr d (Vec n t) -> GLExpr d t
z_ GLExpr d (Vec 3 t)
v)
instance (GLPrim t, GLType (Vec 4 t)) => Deconstructible (GLExpr d (Vec 4 t)) where
    type Decon (GLExpr d (Vec 4 t)) = (GLExpr d t, GLExpr d t, GLExpr d t, GLExpr d t) 
    decon :: GLExpr d (Vec 4 t) -> Decon (GLExpr d (Vec 4 t))
decon GLExpr d (Vec 4 t)
v = (forall {n :: Nat} {t} {d :: GLDomain}.
(OrdCond (CmpNat 1 n) 'True 'True 'False ~ 'True, GLType t,
 GLType (Vec n t)) =>
GLExpr d (Vec n t) -> GLExpr d t
x_ GLExpr d (Vec 4 t)
v, forall {n :: Nat} {t} {d :: GLDomain}.
(OrdCond (CmpNat 2 n) 'True 'True 'False ~ 'True, GLType t,
 GLType (Vec n t)) =>
GLExpr d (Vec n t) -> GLExpr d t
y_ GLExpr d (Vec 4 t)
v, forall {n :: Nat} {t} {d :: GLDomain}.
(OrdCond (CmpNat 3 n) 'True 'True 'False ~ 'True, GLType t,
 GLType (Vec n t)) =>
GLExpr d (Vec n t) -> GLExpr d t
z_ GLExpr d (Vec 4 t)
v, forall {n :: Nat} {t} {d :: GLDomain}.
(OrdCond (CmpNat 4 n) 'True 'True 'False ~ 'True, GLType t,
 GLType (Vec n t)) =>
GLExpr d (Vec n t) -> GLExpr d t
w_ GLExpr d (Vec 4 t)
v)
instance (GLPrim t, GLType (Mat p 2 t), GLType (Vec p t)) => Deconstructible (GLExpr d (Mat p 2 t)) where
    type Decon (GLExpr d (Mat p 2 t)) = (GLExpr d (Vec p t), GLExpr d (Vec p t)) 
    decon :: GLExpr d (Mat p 2 t) -> Decon (GLExpr d (Mat p 2 t))
decon GLExpr d (Mat p 2 t)
m = (forall {c :: Nat} {r :: Nat} {t1} {d :: GLDomain}.
(OrdCond (CmpNat 1 c) 'True 'True 'False ~ 'True,
 GLType (Mat r c t1), GLType (Mat r 1 t1)) =>
GLExpr d (Mat r c t1) -> GLExpr d (Mat r 1 t1)
col0 GLExpr d (Mat p 2 t)
m, forall {c :: Nat} {r :: Nat} {t1} {d :: GLDomain}.
(OrdCond (CmpNat 2 c) 'True 'True 'False ~ 'True,
 GLType (Mat r c t1), GLType (Mat r 1 t1)) =>
GLExpr d (Mat r c t1) -> GLExpr d (Mat r 1 t1)
col1 GLExpr d (Mat p 2 t)
m)
instance (GLPrim t, GLType (Mat p 3 t), GLType (Vec p t)) => Deconstructible (GLExpr d (Mat p 3 t)) where
    type Decon (GLExpr d (Mat p 3 t)) = (GLExpr d (Vec p t), GLExpr d (Vec p t), GLExpr d (Vec p t)) 
    decon :: GLExpr d (Mat p 3 t) -> Decon (GLExpr d (Mat p 3 t))
decon GLExpr d (Mat p 3 t)
m = (forall {c :: Nat} {r :: Nat} {t1} {d :: GLDomain}.
(OrdCond (CmpNat 1 c) 'True 'True 'False ~ 'True,
 GLType (Mat r c t1), GLType (Mat r 1 t1)) =>
GLExpr d (Mat r c t1) -> GLExpr d (Mat r 1 t1)
col0 GLExpr d (Mat p 3 t)
m, forall {c :: Nat} {r :: Nat} {t1} {d :: GLDomain}.
(OrdCond (CmpNat 2 c) 'True 'True 'False ~ 'True,
 GLType (Mat r c t1), GLType (Mat r 1 t1)) =>
GLExpr d (Mat r c t1) -> GLExpr d (Mat r 1 t1)
col1 GLExpr d (Mat p 3 t)
m, forall {c :: Nat} {r :: Nat} {t1} {d :: GLDomain}.
(OrdCond (CmpNat 3 c) 'True 'True 'False ~ 'True,
 GLType (Mat r c t1), GLType (Mat r 1 t1)) =>
GLExpr d (Mat r c t1) -> GLExpr d (Mat r 1 t1)
col2 GLExpr d (Mat p 3 t)
m)
instance (GLPrim t, GLType (Mat p 4 t), GLType (Vec p t)) => Deconstructible (GLExpr d (Mat p 4 t)) where
    type Decon (GLExpr d (Mat p 4 t)) = (GLExpr d (Vec p t), GLExpr d (Vec p t), GLExpr d (Vec p t), GLExpr d (Vec p t)) 
    decon :: GLExpr d (Mat p 4 t) -> Decon (GLExpr d (Mat p 4 t))
decon GLExpr d (Mat p 4 t)
m = (forall {c :: Nat} {r :: Nat} {t1} {d :: GLDomain}.
(OrdCond (CmpNat 1 c) 'True 'True 'False ~ 'True,
 GLType (Mat r c t1), GLType (Mat r 1 t1)) =>
GLExpr d (Mat r c t1) -> GLExpr d (Mat r 1 t1)
col0 GLExpr d (Mat p 4 t)
m, forall {c :: Nat} {r :: Nat} {t1} {d :: GLDomain}.
(OrdCond (CmpNat 2 c) 'True 'True 'False ~ 'True,
 GLType (Mat r c t1), GLType (Mat r 1 t1)) =>
GLExpr d (Mat r c t1) -> GLExpr d (Mat r 1 t1)
col1 GLExpr d (Mat p 4 t)
m, forall {c :: Nat} {r :: Nat} {t1} {d :: GLDomain}.
(OrdCond (CmpNat 3 c) 'True 'True 'False ~ 'True,
 GLType (Mat r c t1), GLType (Mat r 1 t1)) =>
GLExpr d (Mat r c t1) -> GLExpr d (Mat r 1 t1)
col2 GLExpr d (Mat p 4 t)
m, forall {c :: Nat} {r :: Nat} {t1} {d :: GLDomain}.
(OrdCond (CmpNat 4 c) 'True 'True 'False ~ 'True,
 GLType (Mat r c t1), GLType (Mat r 1 t1)) =>
GLExpr d (Mat r c t1) -> GLExpr d (Mat r 1 t1)
col3 GLExpr d (Mat p 4 t)
m)


-- * Expression type conversion

-- | Coerce the primitive type of a value to arbitrary primitive type
cast :: GLExpr d t1 -> GLExpr d t
cast GLExpr d t1
x = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t1 t (d :: GLDomain).
(GLPrim t1, GLPrim t) =>
GLExpr d t1 -> GLGenExpr d t
Cast GLExpr d t1
x
-- | Coerce the element type of a matrix to an arbitrary primitive type
matCast :: GLExpr d (Mat p q t1) -> GLExpr d (Mat p q t2)
matCast GLExpr d (Mat p q t1)
m = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t1 t2 (p :: Nat) (q :: Nat) (d :: GLDomain).
(GLPrim t1, GLPrim t2, KnownNat p, KnownNat q) =>
GLExpr d (Mat p q t1) -> GLGenExpr d (Mat p q t2)
MatCast GLExpr d (Mat p q t1)
m


-- * Built-in operators and functions

infixl 6  .+, .-
infixl 7  .*, ./, .%
infix 4 .<, .<=, .>, .>=, .==, ./=
infixl 3 .&&
infixl 1 .||
infixl 2 .^^
infixl 5 .<<, .>>
infixl 3 .&
infixl 1 .|
infixl 2 .^
infixl 7 .#
infixl 7 .@

GLExpr d t
x .+ :: GLExpr d t -> GLExpr d t -> GLExpr d t
.+ GLExpr d t
y = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain).
(GLNumeric (GLElt t), GLType t) =>
GLExpr d t -> GLExpr d t -> GLGenExpr d t
OpAdd GLExpr d t
x GLExpr d t
y
GLExpr d t
x .- :: GLExpr d t -> GLExpr d t -> GLExpr d t
.- GLExpr d t
y = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain).
(GLNumeric (GLElt t), GLType t) =>
GLExpr d t -> GLExpr d t -> GLGenExpr d t
OpSubt GLExpr d t
x GLExpr d t
y
GLExpr d t
x .* :: GLExpr d t -> GLExpr d t -> GLExpr d t
.* GLExpr d t
y = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain).
(GLNumeric (GLElt t), GLType t) =>
GLExpr d t -> GLExpr d t -> GLGenExpr d t
OpMult GLExpr d t
x GLExpr d t
y
GLExpr d t
x ./ :: GLExpr d t -> GLExpr d t -> GLExpr d t
./ GLExpr d t
y = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain).
(GLNumeric (GLElt t), GLType t) =>
GLExpr d t -> GLExpr d t -> GLGenExpr d t
OpDiv GLExpr d t
x GLExpr d t
y
GLExpr d t
x .% :: GLExpr d t -> GLExpr d t -> GLExpr d t
.% GLExpr d t
y = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain).
(GLInteger (GLElt t), GLPrimOrVec t) =>
GLExpr d t -> GLExpr d t -> GLGenExpr d t
OpMod GLExpr d t
x GLExpr d t
y
-- | Arithmetic negation 
neg :: GLExpr d t -> GLExpr d t
neg GLExpr d t
x = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain).
(GLNumeric (GLElt t), GLType t) =>
GLExpr d t -> GLGenExpr d t
OpNeg GLExpr d t
x
GLExpr d t1
x .< :: GLExpr d t1 -> GLExpr d t1 -> GLExpr d Bool
.< GLExpr d t1
y = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t1 (d :: GLDomain).
GLNumeric t1 =>
GLExpr d t1 -> GLExpr d t1 -> GLGenExpr d Bool
OpLessThan GLExpr d t1
x GLExpr d t1
y
GLExpr d t1
x .<= :: GLExpr d t1 -> GLExpr d t1 -> GLExpr d Bool
.<= GLExpr d t1
y = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t1 (d :: GLDomain).
GLNumeric t1 =>
GLExpr d t1 -> GLExpr d t1 -> GLGenExpr d Bool
OpLessThanEqual GLExpr d t1
x GLExpr d t1
y
GLExpr d t1
x .> :: GLExpr d t1 -> GLExpr d t1 -> GLExpr d Bool
.> GLExpr d t1
y = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t1 (d :: GLDomain).
GLNumeric t1 =>
GLExpr d t1 -> GLExpr d t1 -> GLGenExpr d Bool
OpGreaterThan GLExpr d t1
x GLExpr d t1
y
GLExpr d t1
x .>= :: GLExpr d t1 -> GLExpr d t1 -> GLExpr d Bool
.>= GLExpr d t1
y = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t1 (d :: GLDomain).
GLNumeric t1 =>
GLExpr d t1 -> GLExpr d t1 -> GLGenExpr d Bool
OpGreaterThanEqual GLExpr d t1
x GLExpr d t1
y
GLExpr d t1
x .== :: GLExpr d t1 -> GLExpr d t1 -> GLExpr d Bool
.== GLExpr d t1
y = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t1 (d :: GLDomain).
GLType t1 =>
GLExpr d t1 -> GLExpr d t1 -> GLGenExpr d Bool
OpEqual GLExpr d t1
x GLExpr d t1
y
GLExpr d t1
x ./= :: GLExpr d t1 -> GLExpr d t1 -> GLExpr d Bool
./= GLExpr d t1
y = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t1 (d :: GLDomain).
GLType t1 =>
GLExpr d t1 -> GLExpr d t1 -> GLGenExpr d Bool
OpNotEqual GLExpr d t1
x GLExpr d t1
y
GLExpr d Bool
x .&& :: GLExpr d Bool -> GLExpr d Bool -> GLExpr d Bool
.&& GLExpr d Bool
y = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall (d :: GLDomain).
GLExpr d Bool -> GLExpr d Bool -> GLGenExpr d Bool
OpAnd GLExpr d Bool
x GLExpr d Bool
y
GLExpr d Bool
x .|| :: GLExpr d Bool -> GLExpr d Bool -> GLExpr d Bool
.|| GLExpr d Bool
y = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall (d :: GLDomain).
GLExpr d Bool -> GLExpr d Bool -> GLGenExpr d Bool
OpOr GLExpr d Bool
x GLExpr d Bool
y
GLExpr d Bool
x .^^ :: GLExpr d Bool -> GLExpr d Bool -> GLExpr d Bool
.^^ GLExpr d Bool
y = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall (d :: GLDomain).
GLExpr d Bool -> GLExpr d Bool -> GLGenExpr d Bool
OpXor GLExpr d Bool
x GLExpr d Bool
y
-- | Logical not
nt :: GLExpr d Bool -> GLExpr d Bool
nt GLExpr d Bool
x = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall (d :: GLDomain). GLExpr d Bool -> GLGenExpr d Bool
OpNot GLExpr d Bool
x
-- | Conditional operator, evaluating and returning its second or third argument
-- if the first evaluates to true or false, respectively
cond :: GLExpr d Bool -> GLExpr d t -> GLExpr d t -> GLExpr d t
cond GLExpr d Bool
x GLExpr d t
y GLExpr d t
z = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain).
GLType t =>
GLExpr d Bool -> GLExpr d t -> GLExpr d t -> GLGenExpr d t
OpCond GLExpr d Bool
x GLExpr d t
y GLExpr d t
z
GLExpr d t
x .<< :: GLExpr d t -> GLExpr d t -> GLExpr d t
.<< GLExpr d t
y = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain).
GLSupportsBitwiseOps t =>
GLExpr d t -> GLExpr d t -> GLGenExpr d t
OpLshift GLExpr d t
x GLExpr d t
y
GLExpr d t
x .>> :: GLExpr d t -> GLExpr d t -> GLExpr d t
.>> GLExpr d t
y = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain).
GLSupportsBitwiseOps t =>
GLExpr d t -> GLExpr d t -> GLGenExpr d t
OpRshift GLExpr d t
x GLExpr d t
y
GLExpr d t
x .& :: GLExpr d t -> GLExpr d t -> GLExpr d t
.& GLExpr d t
y = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain).
GLSupportsBitwiseOps t =>
GLExpr d t -> GLExpr d t -> GLGenExpr d t
OpBitAnd GLExpr d t
x GLExpr d t
y
GLExpr d t
x .| :: GLExpr d t -> GLExpr d t -> GLExpr d t
.| GLExpr d t
y = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain).
GLSupportsBitwiseOps t =>
GLExpr d t -> GLExpr d t -> GLGenExpr d t
OpBitOr GLExpr d t
x GLExpr d t
y
GLExpr d t
x .^ :: GLExpr d t -> GLExpr d t -> GLExpr d t
.^ GLExpr d t
y = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain).
GLSupportsBitwiseOps t =>
GLExpr d t -> GLExpr d t -> GLGenExpr d t
OpBitXor GLExpr d t
x GLExpr d t
y
-- | One's complement
compl :: GLExpr d t -> GLExpr d t
compl GLExpr d t
x = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain).
GLSupportsBitwiseOps t =>
GLExpr d t -> GLGenExpr d t
OpCompl GLExpr d t
x
-- | Scalar multiplication
GLExpr d t1
x .# :: GLExpr d t1 -> GLExpr d (Mat p q t1) -> GLExpr d (Mat p q t1)
.# GLExpr d (Mat p q t1)
y = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t1 (p :: Nat) (q :: Nat) (d :: GLDomain).
(GLNumeric t1, GLType (Mat p q t1)) =>
GLExpr d t1 -> GLExpr d (Mat p q t1) -> GLGenExpr d (Mat p q t1)
OpScalarMult GLExpr d t1
x GLExpr d (Mat p q t1)
y
-- | Matrix multiplication
GLExpr d (Mat p q t1)
x .@ :: GLExpr d (Mat p q t1)
-> GLExpr d (Mat q r t1) -> GLExpr d (Mat p r t1)
.@ GLExpr d (Mat q r t1)
y = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t1 (p :: Nat) (q :: Nat) (r :: Nat) (d :: GLDomain).
(GLFloating t1, GLType (Mat p q t1), GLType (Mat q r t1),
 GLType (Mat p r t1)) =>
GLExpr d (Mat p q t1)
-> GLExpr d (Mat q r t1) -> GLGenExpr d (Mat p r t1)
OpMatrixMult GLExpr d (Mat p q t1)
x GLExpr d (Mat q r t1)
y

radians :: GLExpr d t -> GLExpr d t
radians GLExpr d t
x = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain).
(GLElt t ~ Float, GLPrimOrVec t) =>
GLExpr d t -> GLGenExpr d t
Radians GLExpr d t
x
degrees :: GLExpr d t -> GLExpr d t
degrees GLExpr d t
x = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain).
(GLElt t ~ Float, GLPrimOrVec t) =>
GLExpr d t -> GLGenExpr d t
Degrees GLExpr d t
x
sin :: GLExpr d t -> GLExpr d t
sin GLExpr d t
x = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain).
(GLElt t ~ Float, GLPrimOrVec t) =>
GLExpr d t -> GLGenExpr d t
Sin GLExpr d t
x
cos :: GLExpr d t -> GLExpr d t
cos GLExpr d t
x = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain).
(GLElt t ~ Float, GLPrimOrVec t) =>
GLExpr d t -> GLGenExpr d t
Cos GLExpr d t
x
tan :: GLExpr d t -> GLExpr d t
tan GLExpr d t
x = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain).
(GLElt t ~ Float, GLPrimOrVec t) =>
GLExpr d t -> GLGenExpr d t
Tan GLExpr d t
x
asin :: GLExpr d t -> GLExpr d t
asin GLExpr d t
x = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain).
(GLElt t ~ Float, GLPrimOrVec t) =>
GLExpr d t -> GLGenExpr d t
Asin GLExpr d t
x
acos :: GLExpr d t -> GLExpr d t
acos GLExpr d t
x = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain).
(GLElt t ~ Float, GLPrimOrVec t) =>
GLExpr d t -> GLGenExpr d t
Acos GLExpr d t
x
atan :: GLExpr d t -> GLExpr d t
atan GLExpr d t
x = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain).
(GLElt t ~ Float, GLPrimOrVec t) =>
GLExpr d t -> GLGenExpr d t
Atan GLExpr d t
x
sinh :: GLExpr d t -> GLExpr d t
sinh GLExpr d t
x = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain).
(GLElt t ~ Float, GLPrimOrVec t) =>
GLExpr d t -> GLGenExpr d t
Sin GLExpr d t
x
cosh :: GLExpr d t -> GLExpr d t
cosh GLExpr d t
x = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain).
(GLElt t ~ Float, GLPrimOrVec t) =>
GLExpr d t -> GLGenExpr d t
Cos GLExpr d t
x
tanh :: GLExpr d t -> GLExpr d t
tanh GLExpr d t
x = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain).
(GLElt t ~ Float, GLPrimOrVec t) =>
GLExpr d t -> GLGenExpr d t
Tan GLExpr d t
x
asinh :: GLExpr d t -> GLExpr d t
asinh GLExpr d t
x = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain).
(GLElt t ~ Float, GLPrimOrVec t) =>
GLExpr d t -> GLGenExpr d t
Asin GLExpr d t
x
acosh :: GLExpr d t -> GLExpr d t
acosh GLExpr d t
x = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain).
(GLElt t ~ Float, GLPrimOrVec t) =>
GLExpr d t -> GLGenExpr d t
Acos GLExpr d t
x
atanh :: GLExpr d t -> GLExpr d t
atanh GLExpr d t
x = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain).
(GLElt t ~ Float, GLPrimOrVec t) =>
GLExpr d t -> GLGenExpr d t
Atan GLExpr d t
x

pow :: GLExpr d t -> GLExpr d t -> GLExpr d t
pow GLExpr d t
x GLExpr d t
y = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain).
(GLElt t ~ Float, GLPrimOrVec t) =>
GLExpr d t -> GLExpr d t -> GLGenExpr d t
Pow GLExpr d t
x GLExpr d t
y
exp :: GLExpr d t -> GLExpr d t
exp GLExpr d t
x = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain).
(GLElt t ~ Float, GLPrimOrVec t) =>
GLExpr d t -> GLGenExpr d t
Exp GLExpr d t
x
log :: GLExpr d t -> GLExpr d t
log GLExpr d t
x = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain).
(GLElt t ~ Float, GLPrimOrVec t) =>
GLExpr d t -> GLGenExpr d t
Log GLExpr d t
x
exp2 :: GLExpr d t -> GLExpr d t
exp2 GLExpr d t
x = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain).
(GLElt t ~ Float, GLPrimOrVec t) =>
GLExpr d t -> GLGenExpr d t
Exp2 GLExpr d t
x
log2 :: GLExpr d t -> GLExpr d t
log2 GLExpr d t
x = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain).
(GLElt t ~ Float, GLPrimOrVec t) =>
GLExpr d t -> GLGenExpr d t
Log2 GLExpr d t
x
sqrt :: GLExpr d t -> GLExpr d t
sqrt GLExpr d t
x = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain).
(GLFloating (GLElt t), GLPrimOrVec t) =>
GLExpr d t -> GLGenExpr d t
Sqrt GLExpr d t
x
inversesqrt :: GLExpr d t -> GLExpr d t
inversesqrt GLExpr d t
x = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain).
(GLFloating (GLElt t), GLPrimOrVec t) =>
GLExpr d t -> GLGenExpr d t
Inversesqrt GLExpr d t
x

abs :: GLExpr d t -> GLExpr d t
abs GLExpr d t
x = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain).
(GLSigned (GLElt t), GLPrimOrVec t) =>
GLExpr d t -> GLGenExpr d t
Abs GLExpr d t
x
sign :: GLExpr d t -> GLExpr d t
sign GLExpr d t
x = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain).
(GLSigned (GLElt t), GLPrimOrVec t) =>
GLExpr d t -> GLGenExpr d t
Sign GLExpr d t
x
floor :: GLExpr d t -> GLExpr d t
floor GLExpr d t
x = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain).
(GLFloating (GLElt t), GLPrimOrVec t) =>
GLExpr d t -> GLGenExpr d t
Floor GLExpr d t
x
trunc :: GLExpr d t -> GLExpr d t
trunc GLExpr d t
x = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain).
(GLFloating (GLElt t), GLPrimOrVec t) =>
GLExpr d t -> GLGenExpr d t
Trunc GLExpr d t
x
round :: GLExpr d t -> GLExpr d t
round GLExpr d t
x = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain).
(GLFloating (GLElt t), GLPrimOrVec t) =>
GLExpr d t -> GLGenExpr d t
Round GLExpr d t
x
roundEven :: GLExpr d t -> GLExpr d t
roundEven GLExpr d t
x = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain).
(GLFloating (GLElt t), GLPrimOrVec t) =>
GLExpr d t -> GLGenExpr d t
RoundEven GLExpr d t
x
ceil :: GLExpr d t -> GLExpr d t
ceil GLExpr d t
x = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain).
(GLFloating (GLElt t), GLPrimOrVec t) =>
GLExpr d t -> GLGenExpr d t
Ceil GLExpr d t
x
fract :: GLExpr d t -> GLExpr d t
fract GLExpr d t
x = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain).
(GLFloating (GLElt t), GLPrimOrVec t) =>
GLExpr d t -> GLGenExpr d t
Fract GLExpr d t
x
mod :: GLExpr d t -> GLExpr d t -> GLExpr d t
mod GLExpr d t
x GLExpr d t
y = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain).
(GLFloating (GLElt t), GLPrimOrVec t) =>
GLExpr d t -> GLExpr d t -> GLGenExpr d t
Mod GLExpr d t
x GLExpr d t
y
min :: GLExpr d t -> GLExpr d t -> GLExpr d t
min GLExpr d t
x GLExpr d t
y = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain).
(GLNumeric (GLElt t), GLPrimOrVec t) =>
GLExpr d t -> GLExpr d t -> GLGenExpr d t
Min GLExpr d t
x GLExpr d t
y
max :: GLExpr d t -> GLExpr d t -> GLExpr d t
max GLExpr d t
x GLExpr d t
y = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain).
(GLNumeric (GLElt t), GLPrimOrVec t) =>
GLExpr d t -> GLExpr d t -> GLGenExpr d t
Max GLExpr d t
x GLExpr d t
y
clamp :: GLExpr d t -> GLExpr d t -> GLExpr d t -> GLExpr d t
clamp GLExpr d t
x GLExpr d t
y GLExpr d t
z = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain).
(GLNumeric (GLElt t), GLPrimOrVec t) =>
GLExpr d t -> GLExpr d t -> GLExpr d t -> GLGenExpr d t
Clamp GLExpr d t
x GLExpr d t
y GLExpr d t
z
mix :: GLExpr d t -> GLExpr d t -> GLExpr d t -> GLExpr d t
mix GLExpr d t
x GLExpr d t
y GLExpr d t
z = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain).
(GLFloating (GLElt t), GLPrimOrVec t) =>
GLExpr d t -> GLExpr d t -> GLExpr d t -> GLGenExpr d t
Mix GLExpr d t
x GLExpr d t
y GLExpr d t
z
step :: GLExpr d t -> GLExpr d t -> GLExpr d t
step GLExpr d t
x GLExpr d t
y = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain).
(GLFloating (GLElt t), GLPrimOrVec t) =>
GLExpr d t -> GLExpr d t -> GLGenExpr d t
Step GLExpr d t
x GLExpr d t
y
smoothstep :: GLExpr d t -> GLExpr d t -> GLExpr d t -> GLExpr d t
smoothstep GLExpr d t
x GLExpr d t
y GLExpr d t
z = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain).
(GLFloating (GLElt t), GLPrimOrVec t) =>
GLExpr d t -> GLExpr d t -> GLExpr d t -> GLGenExpr d t
Smoothstep GLExpr d t
x GLExpr d t
y GLExpr d t
z

length :: GLExpr d (Vec n t) -> GLExpr d t
length GLExpr d (Vec n t)
x = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain) (n :: Nat).
GLFloating t =>
GLExpr d (Vec n t) -> GLGenExpr d t
Length GLExpr d (Vec n t)
x
distance :: GLExpr d (Vec n t) -> GLExpr d (Vec n t) -> GLExpr d t
distance GLExpr d (Vec n t)
x GLExpr d (Vec n t)
y = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t (d :: GLDomain) (n :: Nat).
GLFloating t =>
GLExpr d (Vec n t) -> GLExpr d (Vec n t) -> GLGenExpr d t
Distance GLExpr d (Vec n t)
x  GLExpr d (Vec n t)
y
dot :: GLExpr d (Vec n t) -> GLExpr d (Vec n t) -> GLExpr d t
dot GLExpr d (Vec n t)
x GLExpr d (Vec n t)
y = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t (n :: Nat) (d :: GLDomain).
(GLFloating t, GLType (Vec n t)) =>
GLExpr d (Vec n t) -> GLExpr d (Vec n t) -> GLGenExpr d t
Dot GLExpr d (Vec n t)
x GLExpr d (Vec n t)
y
cross :: GLExpr d (Vec 3 t1) -> GLExpr d (Vec 3 t1) -> GLExpr d (Vec 3 t1)
cross GLExpr d (Vec 3 t1)
x GLExpr d (Vec 3 t1)
y = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t1 (d :: GLDomain).
(GLFloating t1, GLType (Vec 3 t1)) =>
GLExpr d (Vec 3 t1)
-> GLExpr d (Vec 3 t1) -> GLGenExpr d (Vec 3 t1)
Cross GLExpr d (Vec 3 t1)
x GLExpr d (Vec 3 t1)
y
normalize :: GLExpr d (Vec n t1) -> GLExpr d (Vec n t1)
normalize GLExpr d (Vec n t1)
x = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t1 (n :: Nat) (d :: GLDomain).
(GLFloating t1, GLType (Vec n t1)) =>
GLExpr d (Vec n t1) -> GLGenExpr d (Vec n t1)
Normalize GLExpr d (Vec n t1)
x
faceforward :: GLExpr d (Vec n t1)
-> GLExpr d (Vec n t1)
-> GLExpr d (Vec n t1)
-> GLExpr d (Vec n t1)
faceforward GLExpr d (Vec n t1)
x GLExpr d (Vec n t1)
y GLExpr d (Vec n t1)
z = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t1 (n :: Nat) (d :: GLDomain).
(GLFloating t1, KnownNat n, GLType (Vec n t1)) =>
GLExpr d (Vec n t1)
-> GLExpr d (Vec n t1)
-> GLExpr d (Vec n t1)
-> GLGenExpr d (Vec n t1)
Faceforward GLExpr d (Vec n t1)
x GLExpr d (Vec n t1)
y GLExpr d (Vec n t1)
z
reflect :: GLExpr d (Vec n t1) -> GLExpr d (Vec n t1) -> GLExpr d (Vec n t1)
reflect GLExpr d (Vec n t1)
x GLExpr d (Vec n t1)
y = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t1 (n :: Nat) (d :: GLDomain).
(GLFloating t1, KnownNat n, GLType (Vec n t1)) =>
GLExpr d (Vec n t1)
-> GLExpr d (Vec n t1) -> GLGenExpr d (Vec n t1)
Reflect GLExpr d (Vec n t1)
x GLExpr d (Vec n t1)
y
refract :: GLExpr d (Vec n t1)
-> GLExpr d (Vec n t1) -> GLExpr d t1 -> GLExpr d (Vec n t1)
refract GLExpr d (Vec n t1)
x GLExpr d (Vec n t1)
y GLExpr d t1
z = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t1 (n :: Nat) (d :: GLDomain).
(GLFloating t1, KnownNat n, GLType (Vec n t1), GLType t1) =>
GLExpr d (Vec n t1)
-> GLExpr d (Vec n t1) -> GLExpr d t1 -> GLGenExpr d (Vec n t1)
Refract GLExpr d (Vec n t1)
x GLExpr d (Vec n t1)
y GLExpr d t1
z

matrixCompMult :: GLExpr d (Mat p q t1)
-> GLExpr d (Mat p q t1) -> GLExpr d (Mat p q t1)
matrixCompMult GLExpr d (Mat p q t1)
x GLExpr d (Mat p q t1)
y = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t1 (p :: Nat) (q :: Nat) (d :: GLDomain).
(GLFloating t1, GLType (Mat p q t1), GLType (Mat p q t1)) =>
GLExpr d (Mat p q t1)
-> GLExpr d (Mat p q t1) -> GLGenExpr d (Mat p q t1)
MatrixCompMult GLExpr d (Mat p q t1)
x GLExpr d (Mat p q t1)
y
outerProduct :: GLExpr d (Vec p t1) -> GLExpr d (Vec q t1) -> GLExpr d (Mat p q t1)
outerProduct GLExpr d (Vec p t1)
x GLExpr d (Vec q t1)
y = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t1 (q :: Nat) (p :: Nat) (d :: GLDomain).
(GLFloating t1, GLType (Vec q t1), GLType (Mat p q t1)) =>
GLExpr d (Vec p t1)
-> GLExpr d (Vec q t1) -> GLGenExpr d (Mat p q t1)
OuterProduct GLExpr d (Vec p t1)
x GLExpr d (Vec q t1)
y
transpose :: GLExpr d (Mat p q t1) -> GLExpr d (Mat q p t1)
transpose GLExpr d (Mat p q t1)
x = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t1 (p :: Nat) (q :: Nat) (d :: GLDomain).
(GLFloating t1, GLType (Mat p q t1), GLType (Mat q p t1)) =>
GLExpr d (Mat p q t1) -> GLGenExpr d (Mat q p t1)
Transpose GLExpr d (Mat p q t1)
x
determinant :: GLExpr d (Mat p p Float) -> GLExpr d Float
determinant GLExpr d (Mat p p Float)
x = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall (p :: Nat) (d :: GLDomain).
GLType (Mat p p Float) =>
GLExpr d (Mat p p Float) -> GLGenExpr d Float
Determinant GLExpr d (Mat p p Float)
x
inverse :: GLExpr d (Mat p p Float) -> GLExpr d (Mat p p Float)
inverse GLExpr d (Mat p p Float)
x = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall (p :: Nat) (d :: GLDomain).
GLType (Mat p p Float) =>
GLExpr d (Mat p p Float) -> GLGenExpr d (Mat p p Float)
Inverse GLExpr d (Mat p p Float)
x

lessThan :: GLExpr d (Vec n t1)
-> GLExpr d (Vec n t1) -> GLExpr d (Mat n 1 Bool)
lessThan GLExpr d (Vec n t1)
x GLExpr d (Vec n t1)
y = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t1 (n :: Nat) (d :: GLDomain).
(GLSingleNumeric t1, KnownNat n, GLType (Vec n Bool)) =>
GLExpr d (Vec n t1)
-> GLExpr d (Vec n t1) -> GLGenExpr d (Vec n Bool)
LessThan GLExpr d (Vec n t1)
x GLExpr d (Vec n t1)
y
lessThanEqual :: GLExpr d (Vec n t1)
-> GLExpr d (Vec n t1) -> GLExpr d (Mat n 1 Bool)
lessThanEqual GLExpr d (Vec n t1)
x GLExpr d (Vec n t1)
y = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t1 (n :: Nat) (d :: GLDomain).
(GLSingleNumeric t1, KnownNat n, GLType (Vec n Bool)) =>
GLExpr d (Vec n t1)
-> GLExpr d (Vec n t1) -> GLGenExpr d (Vec n Bool)
LessThanEqual GLExpr d (Vec n t1)
x GLExpr d (Vec n t1)
y
greaterThan :: GLExpr d (Vec n t1)
-> GLExpr d (Vec n t1) -> GLExpr d (Mat n 1 Bool)
greaterThan GLExpr d (Vec n t1)
x GLExpr d (Vec n t1)
y = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t1 (n :: Nat) (d :: GLDomain).
(GLSingleNumeric t1, KnownNat n, GLType (Vec n Bool)) =>
GLExpr d (Vec n t1)
-> GLExpr d (Vec n t1) -> GLGenExpr d (Vec n Bool)
GreaterThan GLExpr d (Vec n t1)
x GLExpr d (Vec n t1)
y
greaterThanEqual :: GLExpr d (Vec n t1)
-> GLExpr d (Vec n t1) -> GLExpr d (Mat n 1 Bool)
greaterThanEqual GLExpr d (Vec n t1)
x GLExpr d (Vec n t1)
y = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t1 (n :: Nat) (d :: GLDomain).
(GLSingleNumeric t1, KnownNat n, GLType (Vec n Bool)) =>
GLExpr d (Vec n t1)
-> GLExpr d (Vec n t1) -> GLGenExpr d (Vec n Bool)
GreaterThanEqual GLExpr d (Vec n t1)
x GLExpr d (Vec n t1)
y
equal :: GLExpr d (Vec n t1)
-> GLExpr d (Vec n t1) -> GLExpr d (Mat n 1 Bool)
equal GLExpr d (Vec n t1)
x GLExpr d (Vec n t1)
y = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t1 (n :: Nat) (d :: GLDomain).
(GLSingle t1, KnownNat n, GLType (Vec n Bool)) =>
GLExpr d (Vec n t1)
-> GLExpr d (Vec n t1) -> GLGenExpr d (Vec n Bool)
Equal GLExpr d (Vec n t1)
x GLExpr d (Vec n t1)
y
notEqual :: GLExpr d (Vec n t1)
-> GLExpr d (Vec n t1) -> GLExpr d (Mat n 1 Bool)
notEqual GLExpr d (Vec n t1)
x GLExpr d (Vec n t1)
y = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t1 (n :: Nat) (d :: GLDomain).
(GLSingle t1, KnownNat n, GLType (Vec n Bool)) =>
GLExpr d (Vec n t1)
-> GLExpr d (Vec n t1) -> GLGenExpr d (Vec n Bool)
NotEqual GLExpr d (Vec n t1)
x GLExpr d (Vec n t1)
y
any :: GLExpr d (Vec n Bool) -> GLExpr d Bool
any GLExpr d (Vec n Bool)
x = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall (n :: Nat) (d :: GLDomain).
GLType (Vec n Bool) =>
GLExpr d (Vec n Bool) -> GLGenExpr d Bool
Any GLExpr d (Vec n Bool)
x
all :: GLExpr d (Vec n Bool) -> GLExpr d Bool
all GLExpr d (Vec n Bool)
x = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall (n :: Nat) (d :: GLDomain).
GLType (Vec n Bool) =>
GLExpr d (Vec n Bool) -> GLGenExpr d Bool
All GLExpr d (Vec n Bool)
x
not :: GLExpr d (Vec n Bool) -> GLExpr d (Vec n Bool)
not GLExpr d (Vec n Bool)
x = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall (n :: Nat) (d :: GLDomain).
GLType (Vec n Bool) =>
GLExpr d (Vec n Bool) -> GLGenExpr d (Vec n Bool)
Not GLExpr d (Vec n Bool)
x


-- * Custom function support

makeGenVar :: p -> GLExpr d t
makeGenVar p
_ = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLAtom d t -> GLExpr d t
GLAtom forall t (d :: GLDomain). GLType t => GLAtom d t
GenVar

{-# NOINLINE glFunc1 #-}
glFunc1 :: (GLType t, GLType t1) => 
    (GLExpr d t1 -> GLExpr d t) -> 
     GLExpr d t1 -> GLExpr d t 
glFunc1 :: forall t t1 (d :: GLDomain).
(GLType t, GLType t1) =>
(GLExpr d t1 -> GLExpr d t) -> GLExpr d t1 -> GLExpr d t
glFunc1 GLExpr d t1 -> GLExpr d t
f = (forall t (d :: GLDomain).
GLType t =>
ExprID -> GLFunc d t -> GLExpr d t
GLFunc (forall a. a -> ExprID
genID GLExpr d t1 -> GLExpr d t
f)) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall t t1 (d :: GLDomain).
(GLType t, GLType t1) =>
(GLExpr d t1 -> GLExpr d t)
-> GLExpr d t1 -> GLExpr d t1 -> GLFunc d t
GLFunc1 GLExpr d t1 -> GLExpr d t
f forall {d :: GLDomain}. GLExpr d t1
x
    where x :: GLExpr d t1
x = forall {t} {p} {d :: GLDomain}. GLType t => p -> GLExpr d t
makeGenVar String
"x"
{-# NOINLINE glFunc2 #-}
glFunc2 :: (GLType t, GLType t1, GLType t2) => 
    (GLExpr d t1 -> GLExpr d t2 -> GLExpr d t) -> 
     GLExpr d t1 -> GLExpr d t2 -> GLExpr d t 
glFunc2 :: forall t t1 t2 (d :: GLDomain).
(GLType t, GLType t1, GLType t2) =>
(GLExpr d t1 -> GLExpr d t2 -> GLExpr d t)
-> GLExpr d t1 -> GLExpr d t2 -> GLExpr d t
glFunc2 GLExpr d t1 -> GLExpr d t2 -> GLExpr d t
f = (forall t (d :: GLDomain).
GLType t =>
ExprID -> GLFunc d t -> GLExpr d t
GLFunc (forall a. a -> ExprID
genID GLExpr d t1 -> GLExpr d t2 -> GLExpr d t
f) forall b c a. (b -> c) -> (a -> b) -> a -> c
.) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall t t1 t2 (d :: GLDomain).
(GLType t, GLType t1, GLType t2) =>
(GLExpr d t1 -> GLExpr d t2 -> GLExpr d t)
-> GLExpr d t1
-> GLExpr d t2
-> GLExpr d t1
-> GLExpr d t2
-> GLFunc d t
GLFunc2 GLExpr d t1 -> GLExpr d t2 -> GLExpr d t
f forall {d :: GLDomain}. GLExpr d t1
x forall {d :: GLDomain}. GLExpr d t2
y
    where (GLExpr d t1
x, GLExpr d t2
y) = (forall {t} {p} {d :: GLDomain}. GLType t => p -> GLExpr d t
makeGenVar String
"x", forall {t} {p} {d :: GLDomain}. GLType t => p -> GLExpr d t
makeGenVar String
"y")
{-# NOINLINE glFunc3 #-}
glFunc3 :: (GLType t, GLType t1, GLType t2, GLType t3) => 
    (GLExpr d t1 -> GLExpr d t2 -> GLExpr d t3 -> GLExpr d t) -> 
     GLExpr d t1 -> GLExpr d t2 -> GLExpr d t3 -> GLExpr d t 
glFunc3 :: forall t t1 t2 t3 (d :: GLDomain).
(GLType t, GLType t1, GLType t2, GLType t3) =>
(GLExpr d t1 -> GLExpr d t2 -> GLExpr d t3 -> GLExpr d t)
-> GLExpr d t1 -> GLExpr d t2 -> GLExpr d t3 -> GLExpr d t
glFunc3 GLExpr d t1 -> GLExpr d t2 -> GLExpr d t3 -> GLExpr d t
f = ((forall t (d :: GLDomain).
GLType t =>
ExprID -> GLFunc d t -> GLExpr d t
GLFunc (forall a. a -> ExprID
genID GLExpr d t1 -> GLExpr d t2 -> GLExpr d t3 -> GLExpr d t
f) forall b c a. (b -> c) -> (a -> b) -> a -> c
.) forall b c a. (b -> c) -> (a -> b) -> a -> c
.) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall t t1 t2 t3 (d :: GLDomain).
(GLType t, GLType t1, GLType t2, GLType t3) =>
(GLExpr d t1 -> GLExpr d t2 -> GLExpr d t3 -> GLExpr d t)
-> GLExpr d t1
-> GLExpr d t2
-> GLExpr d t3
-> GLExpr d t1
-> GLExpr d t2
-> GLExpr d t3
-> GLFunc d t
GLFunc3 GLExpr d t1 -> GLExpr d t2 -> GLExpr d t3 -> GLExpr d t
f forall {d :: GLDomain}. GLExpr d t1
x forall {d :: GLDomain}. GLExpr d t2
y forall {d :: GLDomain}. GLExpr d t3
z
    where (GLExpr d t1
x, GLExpr d t2
y, GLExpr d t3
z) = (forall {t} {p} {d :: GLDomain}. GLType t => p -> GLExpr d t
makeGenVar String
"x", forall {t} {p} {d :: GLDomain}. GLType t => p -> GLExpr d t
makeGenVar String
"y", forall {t} {p} {d :: GLDomain}. GLType t => p -> GLExpr d t
makeGenVar String
"z")
{-# NOINLINE glFunc4 #-}
glFunc4 :: (GLType t, GLType t1, GLType t2, GLType t3, GLType t4) => 
    (GLExpr d t1 -> GLExpr d t2 -> GLExpr d t3 -> GLExpr d t4 -> GLExpr d t) -> 
     GLExpr d t1 -> GLExpr d t2 -> GLExpr d t3 -> GLExpr d t4 -> GLExpr d t 
glFunc4 :: forall t t1 t2 t3 t4 (d :: GLDomain).
(GLType t, GLType t1, GLType t2, GLType t3, GLType t4) =>
(GLExpr d t1
 -> GLExpr d t2 -> GLExpr d t3 -> GLExpr d t4 -> GLExpr d t)
-> GLExpr d t1
-> GLExpr d t2
-> GLExpr d t3
-> GLExpr d t4
-> GLExpr d t
glFunc4 GLExpr d t1
-> GLExpr d t2 -> GLExpr d t3 -> GLExpr d t4 -> GLExpr d t
f = (((forall t (d :: GLDomain).
GLType t =>
ExprID -> GLFunc d t -> GLExpr d t
GLFunc (forall a. a -> ExprID
genID GLExpr d t1
-> GLExpr d t2 -> GLExpr d t3 -> GLExpr d t4 -> GLExpr d t
f) forall b c a. (b -> c) -> (a -> b) -> a -> c
.) forall b c a. (b -> c) -> (a -> b) -> a -> c
.) forall b c a. (b -> c) -> (a -> b) -> a -> c
.) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall t t1 t2 t3 (d :: GLDomain) t4.
(GLType t, GLType t1, GLType t2, GLType t3) =>
(GLExpr d t1
 -> GLExpr d t2 -> GLExpr d t3 -> GLExpr d t4 -> GLExpr d t)
-> GLExpr d t1
-> GLExpr d t2
-> GLExpr d t3
-> GLExpr d t4
-> GLExpr d t1
-> GLExpr d t2
-> GLExpr d t3
-> GLExpr d t4
-> GLFunc d t
GLFunc4 GLExpr d t1
-> GLExpr d t2 -> GLExpr d t3 -> GLExpr d t4 -> GLExpr d t
f forall {d :: GLDomain}. GLExpr d t1
x forall {d :: GLDomain}. GLExpr d t2
y forall {d :: GLDomain}. GLExpr d t3
z forall {d :: GLDomain}. GLExpr d t4
w
    where (GLExpr d t1
x, GLExpr d t2
y, GLExpr d t3
z, GLExpr d t4
w) = (forall {t} {p} {d :: GLDomain}. GLType t => p -> GLExpr d t
makeGenVar String
"x", forall {t} {p} {d :: GLDomain}. GLType t => p -> GLExpr d t
makeGenVar String
"y", forall {t} {p} {d :: GLDomain}. GLType t => p -> GLExpr d t
makeGenVar String
"z", forall {t} {p} {d :: GLDomain}. GLType t => p -> GLExpr d t
makeGenVar String
"w")
{-# NOINLINE glFunc5 #-}
glFunc5 :: (GLType t, GLType t1, GLType t2, GLType t3, GLType t4, GLType t5) => 
    (GLExpr d t1 -> GLExpr d t2 -> GLExpr d t3 -> GLExpr d t4 -> GLExpr d t5 -> GLExpr d t) -> 
     GLExpr d t1 -> GLExpr d t2 -> GLExpr d t3 -> GLExpr d t4 -> GLExpr d t5-> GLExpr d t 
glFunc5 :: forall t t1 t2 t3 t4 t5 (d :: GLDomain).
(GLType t, GLType t1, GLType t2, GLType t3, GLType t4,
 GLType t5) =>
(GLExpr d t1
 -> GLExpr d t2
 -> GLExpr d t3
 -> GLExpr d t4
 -> GLExpr d t5
 -> GLExpr d t)
-> GLExpr d t1
-> GLExpr d t2
-> GLExpr d t3
-> GLExpr d t4
-> GLExpr d t5
-> GLExpr d t
glFunc5 GLExpr d t1
-> GLExpr d t2
-> GLExpr d t3
-> GLExpr d t4
-> GLExpr d t5
-> GLExpr d t
f = ((((forall t (d :: GLDomain).
GLType t =>
ExprID -> GLFunc d t -> GLExpr d t
GLFunc (forall a. a -> ExprID
genID GLExpr d t1
-> GLExpr d t2
-> GLExpr d t3
-> GLExpr d t4
-> GLExpr d t5
-> GLExpr d t
f) forall b c a. (b -> c) -> (a -> b) -> a -> c
.) forall b c a. (b -> c) -> (a -> b) -> a -> c
.) forall b c a. (b -> c) -> (a -> b) -> a -> c
.) forall b c a. (b -> c) -> (a -> b) -> a -> c
.) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall t t1 t2 t3 t4 t5 (d :: GLDomain).
(GLType t, GLType t1, GLType t2, GLType t3, GLType t4,
 GLType t5) =>
(GLExpr d t1
 -> GLExpr d t2
 -> GLExpr d t3
 -> GLExpr d t4
 -> GLExpr d t5
 -> GLExpr d t)
-> GLExpr d t1
-> GLExpr d t2
-> GLExpr d t3
-> GLExpr d t4
-> GLExpr d t5
-> GLExpr d t1
-> GLExpr d t2
-> GLExpr d t3
-> GLExpr d t4
-> GLExpr d t5
-> GLFunc d t
GLFunc5 GLExpr d t1
-> GLExpr d t2
-> GLExpr d t3
-> GLExpr d t4
-> GLExpr d t5
-> GLExpr d t
f forall {d :: GLDomain}. GLExpr d t1
x forall {d :: GLDomain}. GLExpr d t2
y forall {d :: GLDomain}. GLExpr d t3
z forall {d :: GLDomain}. GLExpr d t4
w forall {d :: GLDomain}. GLExpr d t5
v
    where (GLExpr d t1
x, GLExpr d t2
y, GLExpr d t3
z, GLExpr d t4
w, GLExpr d t5
v) = (forall {t} {p} {d :: GLDomain}. GLType t => p -> GLExpr d t
makeGenVar String
"x", forall {t} {p} {d :: GLDomain}. GLType t => p -> GLExpr d t
makeGenVar String
"y", forall {t} {p} {d :: GLDomain}. GLType t => p -> GLExpr d t
makeGenVar String
"z", forall {t} {p} {d :: GLDomain}. GLType t => p -> GLExpr d t
makeGenVar String
"w", forall {t} {p} {d :: GLDomain}. GLType t => p -> GLExpr d t
makeGenVar String
"u")
{-# NOINLINE glFunc6 #-}
glFunc6 :: (GLType t, GLType t1, GLType t2, GLType t3, GLType t4, GLType t5, GLType t6) => 
    (GLExpr d t1 -> GLExpr d t2 -> GLExpr d t3 -> GLExpr d t4 -> GLExpr d t5 -> GLExpr d t6 -> GLExpr d t) -> 
     GLExpr d t1 -> GLExpr d t2 -> GLExpr d t3 -> GLExpr d t4 -> GLExpr d t5 -> GLExpr d t6 -> GLExpr d t 
glFunc6 :: forall t t1 t2 t3 t4 t5 t6 (d :: GLDomain).
(GLType t, GLType t1, GLType t2, GLType t3, GLType t4, GLType t5,
 GLType t6) =>
(GLExpr d t1
 -> GLExpr d t2
 -> GLExpr d t3
 -> GLExpr d t4
 -> GLExpr d t5
 -> GLExpr d t6
 -> GLExpr d t)
-> GLExpr d t1
-> GLExpr d t2
-> GLExpr d t3
-> GLExpr d t4
-> GLExpr d t5
-> GLExpr d t6
-> GLExpr d t
glFunc6 GLExpr d t1
-> GLExpr d t2
-> GLExpr d t3
-> GLExpr d t4
-> GLExpr d t5
-> GLExpr d t6
-> GLExpr d t
f = (((((forall t (d :: GLDomain).
GLType t =>
ExprID -> GLFunc d t -> GLExpr d t
GLFunc (forall a. a -> ExprID
genID GLExpr d t1
-> GLExpr d t2
-> GLExpr d t3
-> GLExpr d t4
-> GLExpr d t5
-> GLExpr d t6
-> GLExpr d t
f) forall b c a. (b -> c) -> (a -> b) -> a -> c
.) forall b c a. (b -> c) -> (a -> b) -> a -> c
.) forall b c a. (b -> c) -> (a -> b) -> a -> c
.) forall b c a. (b -> c) -> (a -> b) -> a -> c
.) forall b c a. (b -> c) -> (a -> b) -> a -> c
.) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall t t1 t2 t3 t4 t5 t6 (d :: GLDomain).
(GLType t, GLType t1, GLType t2, GLType t3, GLType t4, GLType t5,
 GLType t6) =>
(GLExpr d t1
 -> GLExpr d t2
 -> GLExpr d t3
 -> GLExpr d t4
 -> GLExpr d t5
 -> GLExpr d t6
 -> GLExpr d t)
-> GLExpr d t1
-> GLExpr d t2
-> GLExpr d t3
-> GLExpr d t4
-> GLExpr d t5
-> GLExpr d t6
-> GLExpr d t1
-> GLExpr d t2
-> GLExpr d t3
-> GLExpr d t4
-> GLExpr d t5
-> GLExpr d t6
-> GLFunc d t
GLFunc6 GLExpr d t1
-> GLExpr d t2
-> GLExpr d t3
-> GLExpr d t4
-> GLExpr d t5
-> GLExpr d t6
-> GLExpr d t
f forall {d :: GLDomain}. GLExpr d t1
x forall {d :: GLDomain}. GLExpr d t2
y forall {d :: GLDomain}. GLExpr d t3
z forall {d :: GLDomain}. GLExpr d t4
w forall {d :: GLDomain}. GLExpr d t5
u forall {d :: GLDomain}. GLExpr d t6
v
    where (GLExpr d t1
x, GLExpr d t2
y, GLExpr d t3
z, GLExpr d t4
w, GLExpr d t5
u, GLExpr d t6
v) = (forall {t} {p} {d :: GLDomain}. GLType t => p -> GLExpr d t
makeGenVar String
"x", forall {t} {p} {d :: GLDomain}. GLType t => p -> GLExpr d t
makeGenVar String
"y", forall {t} {p} {d :: GLDomain}. GLType t => p -> GLExpr d t
makeGenVar String
"z", forall {t} {p} {d :: GLDomain}. GLType t => p -> GLExpr d t
makeGenVar String
"w", forall {t} {p} {d :: GLDomain}. GLType t => p -> GLExpr d t
makeGenVar String
"u", forall {t} {p} {d :: GLDomain}. GLType t => p -> GLExpr d t
makeGenVar String
"v")


-- Lifts from raw types

glLift0 :: t -> GLExpr 'HostDomain t
glLift0 t
x = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLAtom d t -> GLExpr d t
GLAtom forall a b. (a -> b) -> a -> b
$ forall t. GLType t => t -> GLAtom 'HostDomain t
GLLift0 t
x
glLift1 :: (t1 -> t) -> GLExpr 'HostDomain t1 -> GLExpr 'HostDomain t
glLift1 t1 -> t
f GLExpr 'HostDomain t1
x = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLAtom d t -> GLExpr d t
GLAtom forall a b. (a -> b) -> a -> b
$ forall t t1.
(GLType t, GLType t1) =>
(t1 -> t) -> GLExpr 'HostDomain t1 -> GLAtom 'HostDomain t
GLLift1 t1 -> t
f GLExpr 'HostDomain t1
x
glLift2 :: (t1 -> t2 -> t)
-> GLExpr 'HostDomain t1
-> GLExpr 'HostDomain t2
-> GLExpr 'HostDomain t
glLift2 t1 -> t2 -> t
f GLExpr 'HostDomain t1
x GLExpr 'HostDomain t2
y = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLAtom d t -> GLExpr d t
GLAtom forall a b. (a -> b) -> a -> b
$ forall t t1 t2.
(GLType t, GLType t1, GLType t2) =>
(t1 -> t2 -> t)
-> GLExpr 'HostDomain t1
-> GLExpr 'HostDomain t2
-> GLAtom 'HostDomain t
GLLift2 t1 -> t2 -> t
f GLExpr 'HostDomain t1
x GLExpr 'HostDomain t2
y
glLift3 :: (t1 -> t2 -> t3 -> t)
-> GLExpr 'HostDomain t1
-> GLExpr 'HostDomain t2
-> GLExpr 'HostDomain t3
-> GLExpr 'HostDomain t
glLift3 t1 -> t2 -> t3 -> t
f GLExpr 'HostDomain t1
x GLExpr 'HostDomain t2
y GLExpr 'HostDomain t3
z = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLAtom d t -> GLExpr d t
GLAtom forall a b. (a -> b) -> a -> b
$ forall t t1 t2 t3.
(GLType t, GLType t1, GLType t2, GLType t3) =>
(t1 -> t2 -> t3 -> t)
-> GLExpr 'HostDomain t1
-> GLExpr 'HostDomain t2
-> GLExpr 'HostDomain t3
-> GLAtom 'HostDomain t
GLLift3 t1 -> t2 -> t3 -> t
f GLExpr 'HostDomain t1
x GLExpr 'HostDomain t2
y GLExpr 'HostDomain t3
z
glLift4 :: (t1 -> t2 -> t3 -> t4 -> t)
-> GLExpr 'HostDomain t1
-> GLExpr 'HostDomain t2
-> GLExpr 'HostDomain t3
-> GLExpr 'HostDomain t4
-> GLExpr 'HostDomain t
glLift4 t1 -> t2 -> t3 -> t4 -> t
f GLExpr 'HostDomain t1
x GLExpr 'HostDomain t2
y GLExpr 'HostDomain t3
z GLExpr 'HostDomain t4
w = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLAtom d t -> GLExpr d t
GLAtom forall a b. (a -> b) -> a -> b
$ forall t t1 t2 t3 t4.
(GLType t, GLType t1, GLType t2, GLType t3, GLType t4) =>
(t1 -> t2 -> t3 -> t4 -> t)
-> GLExpr 'HostDomain t1
-> GLExpr 'HostDomain t2
-> GLExpr 'HostDomain t3
-> GLExpr 'HostDomain t4
-> GLAtom 'HostDomain t
GLLift4 t1 -> t2 -> t3 -> t4 -> t
f GLExpr 'HostDomain t1
x GLExpr 'HostDomain t2
y GLExpr 'HostDomain t3
z GLExpr 'HostDomain t4
w
glLift5 :: (t1 -> t2 -> t3 -> t4 -> t5 -> t)
-> GLExpr 'HostDomain t1
-> GLExpr 'HostDomain t2
-> GLExpr 'HostDomain t3
-> GLExpr 'HostDomain t4
-> GLExpr 'HostDomain t5
-> GLExpr 'HostDomain t
glLift5 t1 -> t2 -> t3 -> t4 -> t5 -> t
f GLExpr 'HostDomain t1
x GLExpr 'HostDomain t2
y GLExpr 'HostDomain t3
z GLExpr 'HostDomain t4
w GLExpr 'HostDomain t5
u = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLAtom d t -> GLExpr d t
GLAtom forall a b. (a -> b) -> a -> b
$ forall t t1 t2 t3 t4 t5.
(GLType t, GLType t1, GLType t2, GLType t3, GLType t4,
 GLType t5) =>
(t1 -> t2 -> t3 -> t4 -> t5 -> t)
-> GLExpr 'HostDomain t1
-> GLExpr 'HostDomain t2
-> GLExpr 'HostDomain t3
-> GLExpr 'HostDomain t4
-> GLExpr 'HostDomain t5
-> GLAtom 'HostDomain t
GLLift5 t1 -> t2 -> t3 -> t4 -> t5 -> t
f GLExpr 'HostDomain t1
x GLExpr 'HostDomain t2
y GLExpr 'HostDomain t3
z GLExpr 'HostDomain t4
w GLExpr 'HostDomain t5
u
glLift6 :: (t1 -> t2 -> t3 -> t4 -> t5 -> t6 -> t)
-> GLExpr 'HostDomain t1
-> GLExpr 'HostDomain t2
-> GLExpr 'HostDomain t3
-> GLExpr 'HostDomain t4
-> GLExpr 'HostDomain t5
-> GLExpr 'HostDomain t6
-> GLExpr 'HostDomain t
glLift6 t1 -> t2 -> t3 -> t4 -> t5 -> t6 -> t
f GLExpr 'HostDomain t1
x GLExpr 'HostDomain t2
y GLExpr 'HostDomain t3
z GLExpr 'HostDomain t4
w GLExpr 'HostDomain t5
u GLExpr 'HostDomain t6
v = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLAtom d t -> GLExpr d t
GLAtom forall a b. (a -> b) -> a -> b
$ forall t t1 t2 t3 t4 t5 t6.
(GLType t, GLType t1, GLType t2, GLType t3, GLType t4, GLType t5,
 GLType t6) =>
(t1 -> t2 -> t3 -> t4 -> t5 -> t6 -> t)
-> GLExpr 'HostDomain t1
-> GLExpr 'HostDomain t2
-> GLExpr 'HostDomain t3
-> GLExpr 'HostDomain t4
-> GLExpr 'HostDomain t5
-> GLExpr 'HostDomain t6
-> GLAtom 'HostDomain t
GLLift6 t1 -> t2 -> t3 -> t4 -> t5 -> t6 -> t
f GLExpr 'HostDomain t1
x GLExpr 'HostDomain t2
y GLExpr 'HostDomain t3
z GLExpr 'HostDomain t4
w GLExpr 'HostDomain t5
u GLExpr 'HostDomain t6
v


-- * Built-in I/O variables

-- | Seconds elapsed since an initial point in time 
time :: HostExpr Float
time :: HostExpr Float
time = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLAtom d t -> GLExpr d t
GLAtom forall a b. (a -> b) -> a -> b
$ String -> GLAtom 'HostDomain Float
IOFloat String
"time"

-- | True if and only if the left mouse button is pressed
mouseLeft :: HostExpr Bool
mouseLeft :: HostExpr Bool
mouseLeft = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLAtom d t -> GLExpr d t
GLAtom forall a b. (a -> b) -> a -> b
$ String -> GLAtom 'HostDomain Bool
IOBool String
"mouseLeft"

-- | True if and only if the right mouse button is pressed
mouseRight :: HostExpr Bool
mouseRight :: HostExpr Bool
mouseRight = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLAtom d t -> GLExpr d t
GLAtom forall a b. (a -> b) -> a -> b
$ String -> GLAtom 'HostDomain Bool
IOBool String
"mouseRight"

-- | A pulse signal, equal to 1 at the moment the mouse wheel scrolls up, -1 when 
-- the mouse wheel scrolls down, and afterwards exponentially decaying to its 
-- otherwise default value of 0
mouseWheel :: HostExpr Float
mouseWheel :: HostExpr Float
mouseWheel = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLAtom d t -> GLExpr d t
GLAtom forall a b. (a -> b) -> a -> b
$ String -> GLAtom 'HostDomain Float
IOFloat String
"mouseWheel"

-- | The horizontal position of the mouse, not necessarily within the window bounds
mouseX :: HostExpr Float
mouseX :: HostExpr Float
mouseX = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLAtom d t -> GLExpr d t
GLAtom forall a b. (a -> b) -> a -> b
$ String -> GLAtom 'HostDomain Float
IOFloat String
"mouseX"

-- | The vertical position of the mouse, not necessarily within the window bounds
mouseY :: HostExpr Float
mouseY :: HostExpr Float
mouseY = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLAtom d t -> GLExpr d t
GLAtom forall a b. (a -> b) -> a -> b
$ String -> GLAtom 'HostDomain Float
IOFloat String
"mouseY"

-- | Equal to @vec2 mouseX mouseY@
mousePos :: HostExpr (Vec 2 Float)
mousePos :: HostExpr (Vec 2 Float)
mousePos = forall {t} {t}. (ExprID -> t -> t) -> t -> t
mkExpr forall t (d :: GLDomain).
GLType t =>
ExprID -> GLGenExpr d t -> GLExpr d t
GLGenExpr forall a b. (a -> b) -> a -> b
$ forall t1 (d :: GLDomain).
GLType (Vec 2 t1) =>
GLExpr d t1 -> GLExpr d t1 -> GLGenExpr d (Vec 2 t1)
GLVec2 HostExpr Float
mouseX HostExpr Float
mouseY


-- * Drawables

-- | Anything that can be drawn using a given 'Backend'
class Drawable a where
    draw :: Backend -> a -> IO ()

-- | A 'GLObj' is drawn by constructing primitives from its 'position' and
-- 'indices' expressions, according to its 'primitiveMode', and coloring the
-- resulting fragments according to its 'color' expression.
instance Drawable GLObj where
    draw :: Backend -> GLObj -> IO ()
draw Backend
backend GLObj
obj = forall a. Drawable a => Backend -> a -> IO ()
draw Backend
backend [GLObj
obj]

-- | A set of 'GLObj's is drawn by drawing each 'GLObj' individually and with the
-- same blending mode as that used to draw a single 'GLObj'.
instance Drawable [GLObj] where
    draw :: Backend -> [GLObj] -> IO ()
draw (GlutBackend GlutOptions
userInit) [GLObj]
objs = GlutOptions -> [GLObj] -> IO ()
runGlut GlutOptions
userInit [GLObj]
objs

defaultObj :: GLObj
defaultObj = GLObj {
    primitiveMode :: PrimitiveMode
primitiveMode = PrimitiveMode
OpenGL.Points,
    indices :: Maybe [ConstExpr UInt]
indices = forall a. Maybe a
Nothing,
    position :: VertExpr (Mat 4 1 Float)
position = forall {t1} {d :: GLDomain}.
GLType (Mat 4 1 t1) =>
GLExpr d t1
-> GLExpr d t1
-> GLExpr d t1
-> GLExpr d t1
-> GLExpr d (Mat 4 1 t1)
vec4 GLExpr 'VertexDomain Float
0 GLExpr 'VertexDomain Float
0 GLExpr 'VertexDomain Float
0 GLExpr 'VertexDomain Float
0,
    color :: FragExpr (Mat 4 1 Float)
color = forall {t1} {d :: GLDomain}.
GLType (Mat 4 1 t1) =>
GLExpr d t1
-> GLExpr d t1
-> GLExpr d t1
-> GLExpr d t1
-> GLExpr d (Mat 4 1 t1)
vec4 GLExpr 'FragmentDomain Float
0 GLExpr 'FragmentDomain Float
0 GLExpr 'FragmentDomain Float
0 GLExpr 'FragmentDomain Float
0,
    discardWhen :: FragExpr Bool
discardWhen = forall (d :: GLDomain). GLExpr d Bool
false
}

-- | An incompletely specified object with 'PrimitiveMode' equal to 'OpenGL.Points'
points :: GLObj
points = GLObj
defaultObj { primitiveMode :: PrimitiveMode
primitiveMode = PrimitiveMode
OpenGL.Points }
-- | An incompletely specified object with 'PrimitiveMode' equal to 'OpenGL.Lines'
lines :: GLObj
lines = GLObj
defaultObj { primitiveMode :: PrimitiveMode
primitiveMode = PrimitiveMode
OpenGL.Lines }
-- | An incompletely specified object with 'PrimitiveMode' equal to 'OpenGL.LineLoop'
lineLoop :: GLObj
lineLoop = GLObj
defaultObj { primitiveMode :: PrimitiveMode
primitiveMode = PrimitiveMode
OpenGL.LineLoop }
-- | An incompletely specified object with 'PrimitiveMode' equal to 'OpenGL.LineStrip'
lineStrip :: GLObj
lineStrip = GLObj
defaultObj { primitiveMode :: PrimitiveMode
primitiveMode = PrimitiveMode
OpenGL.LineStrip }
-- | An incompletely specified object with 'PrimitiveMode' equal to 'OpenGL.Triangles'
triangles :: GLObj
triangles = GLObj
defaultObj { primitiveMode :: PrimitiveMode
primitiveMode = PrimitiveMode
OpenGL.Triangles }
-- | An incompletely specified object with 'PrimitiveMode' equal to 'OpenGL.TriangleStrip'
triangleStrip :: GLObj
triangleStrip = GLObj
defaultObj { primitiveMode :: PrimitiveMode
primitiveMode = PrimitiveMode
OpenGL.TriangleStrip }
-- | An incompletely specified object with 'PrimitiveMode' equal to 'OpenGL.TriangleFan'
triangleFan :: GLObj
triangleFan = GLObj
defaultObj { primitiveMode :: PrimitiveMode
primitiveMode = PrimitiveMode
OpenGL.TriangleFan }
-- | An incompletely specified object with 'PrimitiveMode' equal to 'OpenGL.Quads'
quads :: GLObj
quads = GLObj
defaultObj { primitiveMode :: PrimitiveMode
primitiveMode = PrimitiveMode
OpenGL.Quads }
-- | An incompletely specified object with 'PrimitiveMode' equal to 'OpenGL.QuadStrip'
quadStrip :: GLObj
quadStrip = GLObj
defaultObj { primitiveMode :: PrimitiveMode
primitiveMode = PrimitiveMode
OpenGL.QuadStrip }
-- | An incompletely specified object with 'PrimitiveMode' equal to 'OpenGL.Polygon'
polygon :: GLObj
polygon = GLObj
defaultObj { primitiveMode :: PrimitiveMode
primitiveMode = PrimitiveMode
OpenGL.Polygon }


-- * Backends

-- | A backend that can interpret (draw) a 'Drawable'.
-- Unless overridden the following OpenGL options are set by default in all backends:
--
--  * Clear color equal to black
--
--  * Depth testing enabled
--
--  * Blending enabled with blend equation equal to GL_FUNC_ADD 
--
--  * Source blending factor equal to GL_SRC_ALPHA
--
--  * Destination blending factor equal to  GL_ONE_MINUS_SRC_ALPHA
data Backend =

    GlutBackend GlutOptions

-- | Draw in a GLUT backend using default options
drawGlut :: Drawable a => a -> IO ()
drawGlut :: forall a. Drawable a => a -> IO ()
drawGlut = forall a. Drawable a => Backend -> a -> IO ()
draw (GlutOptions -> Backend
GlutBackend GlutOptions
defaultGlutOptions)

-- | Draw in a GLUT backend using specified options
drawGlutCustom :: Drawable a => GlutOptions -> a -> IO ()
drawGlutCustom :: forall a. Drawable a => GlutOptions -> a -> IO ()
drawGlutCustom GlutOptions
options = forall a. Drawable a => Backend -> a -> IO ()
draw (GlutOptions -> Backend
GlutBackend GlutOptions
options)

-- | Default options for a GLUT backend
--
-- * @winSize = (768, 768)@
-- * @clearCol = (0, 0, 0, 0)@
-- * @runMode = GlutNormal@
defaultGlutOptions :: GlutOptions
defaultGlutOptions :: GlutOptions
defaultGlutOptions = GlutOptions {
    winPosition :: Maybe (GLsizei, GLsizei)
winPosition = forall a. Maybe a
Nothing,
    winSize :: (GLsizei, GLsizei)
winSize = (GLsizei
768, GLsizei
768),
    winFullscreen :: Bool
winFullscreen = Bool
False,
    winTitle :: Maybe String
winTitle = forall a. Maybe a
Nothing,
    clearCol :: (Float, Float, Float, Float)
clearCol = (Float
0, Float
0, Float
0, Float
0),
    runMode :: GlutRunMode
runMode = GlutRunMode
GlutNormal,
    openGLSetup :: IO ()
openGLSetup = forall (m :: * -> *) a. Monad m => a -> m a
return ()
}