Doing computer graphics is fun. So, I wrote another fractal renderer.

In itself, it's rather boring. But this time, I made it a generic tool,
not a specialized "mandelbrot renderer" or something like that. Instead,
the main program only provides you with a GUI to set parameters. It will
then run a loop and call a lua function to determine the color of each
pixel. Looks something like this:

   locators = {"center"}
   color_ramps = {"outcolors"}
   scalars = {"escape", "nmax"}

   function defaults()
       set_locator("center", -0.5, 0, 1)
       set_scalar("escape", 4)
       set_scalar("nmax", 100)
   end

   function value_at(x, y)
       ...

       escape = scalar("escape")
       nmax = scalar("nmax")
       center_x, center_y, zoom = locator("center")

       x = (x * zoom) + center_x
       y = (y * zoom) + center_y

       re_c = x
       im_c = y

       for n = 0, nmax - 1, 1
       do
           ...

           if sqr_abs_z > escape
           then
               ...
               return color_ramp("outcolors", mu)
           end
       end

       return 0.0, 0.0, 0.0
   end

This will construct a GUI on the fly to allow you to set those
parameters. The point is to allow you to easily experiment with
different fractal formulae. This file (`mandelbrot.lua`) is
user-supplied content.

Of course, this is slow as hell. Calling to lua for *every pixel* and
then back to C for some things. It could be optimized a bit, but I don't
think it'll be fast enough.

Instead, I'll try to move everything to C. The idea is to have the user
provide a single `.c` file, compile it on the fly into a shared object,
and run `dlopen()` on the result. Not sure if this actually works, I've
never done it before, so we'll see!

.. aaaand it works. My test case in lua took about 2.4 seconds, the C
version takes about 0.3 seconds. So, a lot faster, but I think/hope
there's still room for improvement.