kmcallister / azurescens Goto Github PK

We should have a mechanism to switch between different modes (e.g. feedback equation, color mapping). This should produce a smooth transition.

Right now, the app needs a restart whenever you switch apps or go back to the homescreen.

between the feedback buffer and the actual displayed image. This could produce results similar to Electric Sheep's flame fractals.

Why not?

Right now we render one frame per vsync, however frequent that is.

It would also be nice to have a mode which displays the framerate.

Probably using OSMesa (#27).

From an old experiment:

In interactive mode, c and a are controlled with a joystick (which makes it feel like a flight simulator on acid). The user can also place control points in this (c,a) space. In animated mode, the parameters move smoothly between these control points along a Catmull-Rom spline, which produces a nice C1 continuous curve.

Support for OSMesa would allow rendering images with no GPU. This is pretty slow although llvmpipe helps. For example, we could save PNGs or output terminal art with libcaca.

I believe glium has some level of OSMesa support already.

Map the feedback image onto a sphere, with head-tracking.

e.g. USB joystick, Wiimote (Bluetooth), Kinect?

It would be really cool to run this same code in a browser.

We can mix in a feed from an actual camera. Pointing the camera at the screen produces extra fun.

Each has its own visual appeal. Linear is nice and smooth. Nearest is spastic and noisy but preserves a lot more information, so the image is more than a function of the current parameter settings.

See nearest branch.

Seems like time isn't passing. The borders do not change color.

Great results

Just add a mode which enforces a vertical / horizontal / radial symmetry.

This should be pretty easy. Just dump the feedback buffer into the image crate. This is simpler and higher-resolution than screenshoting the actual window with OS features.

Ability to save/restore interesting parameter sets.

We want a mode where shaders are loaded from disk at run-time, not compile time.

Maybe this should be a Cargo feature?

An equation that has worked very well in the past:

z' = a*log(z)*c + (1-a)*(z²+c)

where c is a complex parameter (as today) and a is a real parameter between 0 and 1.

Allow modifying FEEDBACK_TEXTURE_SIZE at run-time. Need to recreate textures.

They seem a bit off.