Hi,

I've just released the first version of Fragmentarium (v0.5.6), an open source, cross-platform IDE for exploring pixel based graphics on the GPU.
It was mainly created for exploring Distance Estimated systems, such as Mandelbulbs or Kaleidoscopic IFS, but it can also be used for 2D systems.

It is inspired by Adobe's Pixel Bender, but uses pure GLSL, and is specifically created with fractals and generative systems in mind.

Features:

* Multi-tabbed IDE, with GLSL syntax highlighting
* Modular GLSL programming - include other fragments
* User widgets to manipulate parameter settings.
* Different 'mouse to GLSL' mapping schemes (2D and 3D)
* Includes raytracer for distance estimated systems
* Many examples including Mandelbulb, Mandelbox, Kaleidoscopic IFS, and Julia Quaternion (all systems found here on Fractal Forums)

Fragmentarium is supposed to make GPU programming as easy as possible. For instance, a Distance Estimated system can be formulated in a few lines:

It is also simple to create a custom slider and bind it to a variable in the GLSL code:
The code above will create a slider in the GUI with minimum, default, and maximum values specified in the brackets.

Fragmentarium can be downloaded from:
http://syntopia.github.com/Fragmentarium/

There are binaries for Windows, but for now you'll have to build it yourself for Mac and Linux. You will need a graphics card capable of running GLSL (any reasonably moderne discrete card will do).

Here is a screenshot:



There's also a gallery at Flickr: http://www.flickr.com/groups/fragmentarium/

Fragmentarium is not a mature application yet. Especially the camera handling needs some work in the next versions - camera settings are not saved as part of the parameters, no field-of-view control and you often have to compensate for clipping. For future versions I also plan arbitrary resolution renders (tile based rendering) and animations.

There are probably also many small quirks and bugs - I've had several problems with ATI drivers, which seems to be much more strict than Nvidias.

Regards,
Syntopia

Fragmentarium is not restricted to distance estimated systems - any system will do, as long as it can formulated in such a way that each pixel can be calculated independently.

It just provides an example raytracer for DE-based systems. 

is there an example for how to use the non distance estimation "brute force" methods?
or should i just use the iterationcount/iteration as distance measure ?

rot.box

hybrid with Fragmentarium



test on sample file

Oh, being able to copy log text would be a nice addition. I'll put it on a Todo :-)

Visual's example is from an earlier build, before the 'init()' functions were added. If you want to try his example, insert the following at top of the script:

What the script does is, that it includes two different DE's and renames some variables and functions to prevent name-clashing. I included a similar script in an earlier build, but decided to remove it, because the include/replace procedure got to ugly :-) I'm still looking for a sensible way to combine scripts without nameclashes (something like namespaces).

The 'init()' functions are also a bit of an annoying hack. Before that, the global variables were initialized by just calling functions, e.g.:


But it turns out that some ATI cards crash on user functions call in global variable initializers, so I had to introduce the 'init' functions:

Hi, I've released a new build of Fragmentarium with some much needed updates, including better camera control, high resolution renders, and animation.

New features in version 0.8:
- The 3D camera has been rewritten: it is now a "first-person", pinhole camera (like Boxplorer and Fractal Lab), and is controllable using mouse and keyboard. Camera view can now be saved together with other settings.
- Arbitrary resolution renderings (using tile based rendering - the GPU won't time out).
- Preview modes (renders to FBO with lower resolution and rescales).
- 'Tile preview' for previewing part of high-resolution renders.
- Animation controller (experimental: no keyframes yet, you must animate using the system supplied 'time' variable. Animation is output as a sequence of still images).
- Presets (group parameters settings and load them into a dropbox)
- New fractals: QuaternionMandelbrot4D, Ducks, NewMenger.
- Improved raytracer: dithering, fog, new coloring schemes.

Download here: http://syntopia.github.com/Fragmentarium/get.html

<a href="http://vimeo.com/moogaloop.swf?clip_id=19996015&amp;server=vimeo.com&amp;fullscreen=1&amp;show_title=1&amp;show_byline=1&amp;show_portrait=0&amp;color=01AAEA" target="_blank">http://vimeo.com/moogaloop.swf?clip_id=19996015&amp;server=vimeo.com&amp;fullscreen=1&amp;show_title=1&amp;show_byline=1&amp;show_portrait=0&amp;color=01AAEA</a>
Option for simple animation support.


The 2D Mandelbrot/Julia type fractals have options for embedding a Mandelbrot map. The fractal shown here is Samuel Monnier's 'Ducks' Fractal.


Improved interface with preview sliders. The fractal shown is a Quaternion Mandelbrot.

For a decent mid-range graphics cards (e.g. a Geforce 8800GTX), you will be able to work in realtime with 3D raytraced fractals.

3D fractals calculations using a GPU, such as the 8800GTX, will be somewhere between 7x - 25x faster than a Intel Core 2 Quad CPU. (I made an informal benchmark here: http://blog.hvidtfeldts.net/index.php/2011/02/gpu-versus-cpu-for-pixel-graphics/)

Thanks, David.

If I understand it correctly, you calculate 'dR' as the length of the (numerically approximated) gradient of R. (R being the length of the input point after n iterations). The distance estimate is then: DE = R*log(R)/dR

That seems to be very similar to the Koebe formula (http://en.wikipedia.org/wiki/Mandelbrot_set#Exterior_distance_estimation), the only difference being the use of a gradient instead of the complex derivative. (But shouldn't the DE-estimate be multiplied by 0.5?)

I'll try it out when I get some time.