sleexyz / hylogen Goto Github PK

editor shortcuts to bypass inotify?

hmmm.....

bug is that we need matricies!

Language

• getting started
• copy
• swizzling/unswizzling

Applications with Hylide

• audio reactivity!
• texture-backbuffering
• signed-distance fields

Use it in your own project

• defining your own uniforms

compilation freezes on recursion

for compile time gradients for surface normals :))))))))))))))))))

For faster recompiles

Have hylogen the language generate programs other than those for the hylogen server

3bbf1e3

ended breaking Ctrl-C functionality for hylide

Currently using enter as a replacement, but its kinda awkward...

And clean up javascript code?

via Per-uniform dependency injection

Go from select :: Booly -> Expr a -> Expr a -> Expr a
to select :: (Selectable s) => Booly -> s -> s -> s

where a selectable can be a haskell-side (aka shallowly embedded) ADT, like a tuple

Maybe a separate project?

Pros:

• try-hylogen is possible! zero installation, serverless, all in the browser via ghcjs

Cons:

• purescript not yet slick as haskell
• going to have to prescribe an IDE (codemirror, etc)

Perhaps when this projects gets more mature, we can try an in-browser preview in a try-halogen project

right now sel can only handle primitive input and output types.
One way is to create a Struct/Selectable typeclass that will be selectable

non trivial, this might involve making changes to the AST for a specific Numeric form.
mainly for syntactic niceities

Right now: only one way to make Vec4 from HyloPrims:

Vec4 :: (Vec1, Vec1, Vec1, Vec1) -> Vec4

Desired: More ways:

Vec4 :: (Vec3, Vec1) -> Vec4
...
etc

We've implemented the primitive for a backbuffer.

Now how do we do it for arbitrary images?
specify textures in a local folder?

Compare transpilation and compilation times for pure DSL vs monadic DSL

Now that we have observable sharing via data-reify, CSE is really just icing on the cake.

Ideally: whip out the editor, the browser, and execute just one command

Pros:

• kinda intuitive
• no need to import Data.VectorSpace for scalar multiplication
• ergonomic (the alternative, *^, is a terrible to type)

Cons:

• type-wise confusing
• inconsistent; the programmer might get used to "scalar multiplication" via polymorphism, when it only works on global uniforms

keep js code minimal and simple

Perhaps we need a monadic context (#11)

A few things are inexpressible in the pure DSL:

• rolled for loops: the cost of parsing unrolled loops grows linearly, so currently your compile times actually grow with higher iteration counts :(
• custom uniforms
• GLSL functions

In general we want to generate code that is concise as possible to minimize compile times of the generated GLSL

use Vector Space

like in webpack hot-module reloading

• perlin noise
• random noise
• turbulence

where to put fragment shader boilerplate?

Probably in the Hylogen library

And have app/Main.hs import Hylogen

With GLFW? SDL?