=========================================================
FFFF - Fast Floating Fractal Fun v3.0.0
Author: Daniele Paccaloni (daniele.paccaloni@dylogic.com)
Project page: http://www.sourceforge.net/projects/ffff
=========================================================

FFFF is just the fastest mandelbrot generator for Win32.
It's GNU GPL OpenSource.

HISTORY
-------

In 1994 FFFF v2.0 was the first in TrueColorFractals-Land with the fastest mandel algorithm available.
It made users scream of joy and sorrow, due to the beauty of the images and the incompatibility problems caused by its raw coding (100% machine code, 5 KB executable).
Now it comes back after 8 years - version 3.0.0 - back at the top of technology, speed, and... compatibility :)


INTRO
-----

Speed.
Thanks to my "QuadPixel(TM)" algorythm running on all CPU supporting SSE instructions (P3 or better) and the optimized multiprocessor support.
On a fast machine you should get realtime zooms for a while.
Those of you having a CPU that doesn't support SSE, will get the classic monopixel FPU algorythm.

If it seems slow:
  1) You know OpenGL ! You need a fast board (or new driver).
  2) OpenGL rendering can be the boottleneck! Try zooming a bit, increase maxiters and think again.
  3) There are no zoom/move tricks. All frames you see are entirely calculated. It's *not* fake.
  4) Use a huge window for final renderings only. It's not Quake !

SSE calculation:
QuadPixel calculation means computing 4 pixels at the same time using SSE instructions.
The algorythm does not access memory while calculating all 4 pixels (nice tricks, please look at the src !).

FPU calculation:
Based on that of FFFF v2.0, it's a bit faster but i haven't got time for a pipeline tuning analysis.

GPU calculation:
If you've got an OpenGL board with a GPU supporting Vertex Programs, please check the experimental GPU (Graphics Processing Unit) calculation routine based on that of Erik Lindholm of nVidia (mine was almost identical: i've included Erik's one but with my coloring calc).
It runs fine on my GeForce3 and my nForce420 (BTW: colors are different!).
Don't know if it runs on a GeForce4.. let me know.
Please note:
 1) Vertex Programs do not allow branches nor early exit.
 2) Coloring the pixel is tricky so that the normal palette won't be available (btw, i love that coloring).
 3) Maxiters (max possible iteration limit) is 60.
 4) You'll see CPU usage even if calculating with the GPU, please note that we must send data to it !
 5) Yes, the GPU is SLOWER than your P3 or Athlon.


FEATURES
--------

- 100% asm optimized SSE quad pixel calc (calculates 4 pixel simultaneously at single precision)
- 100% asm optimized FPU per pixel calc (fast FPU at double precision)
- 100% GPU asm (Vertex Program) calc (experimental GPU rendering)
- Benchmarking of CPU performance (test your pc floating point performance)
- OpenGL support (realtime zoom with anti-flicker double buffer support)
- OpenGL 1.1 vertex arrays support for fillrate improvement
- Multiprocessor support, up to [insert your number here] CPUs :)
- True color only (you know me ;)


INSTRUCTIONS
------------

Left mouse button: Zoom in
Right mouse button: Zoom out
Middle mouse button: Move

Keys:
 1: Lame FPU computation, C code.
 2: Fast FPU computation, 100machine code.
 3: Quadfast SSE computation, 100machine code (where available).
 4: GPU Vertex Program computation (where available).
 d: Toggle double/single buffer (you flicker haters).
 +,-: Inc/Dec max iters (press shift for +/-20).
 /,*: Rotate palette.
 h: Shows this help.
 s: Shows stats in console (not yet supported).
 b: Speed benchmark.
    See result in the console.

Please check that CAPSLOCK is off.


HINTS
-----
- The program starts in single buffering mode.
  Please press "d" if you have a fast system and want to enjoy the realtime zoom.
- The SSE calc is fast but uses single float precision.
  When you run out of zoom precision (you'll know when you see it), switch to FPU mode (zoom up to 10^15 times).
- Please note: the current image is never cached.
  If you touch something, i'll recalc ALL.
- You can always get realtime interactive render rates shrinking the window size.
  When you get to the interesting zone, render full screen.
- On deep zooms with high iterations, please switch to single buffer mode to see the rendering in progress.
  Otherwise you won't see anything till the render is complete !
  Use double buffering only at interactive rates.
- Don't touch that lever ! :)
- When you are lost in the dark, all alone, press the '1' key.



COMING SOON
-----------

1) You will get a color editor. By now, the AutoColorizer(TM) AI algorithm chooses the color YOU would have chosen !! :)
   Ahem, i haven't got time to code the color editor. Since the program is OpenSource, i'd like one of you to code it !
2) SSE2 support for DualPixel calculation in double precision (i haven't got a P4, just wait or send me one).
3) Zoom with autoswitch to best calc mode for the specified zoomlevel.
4) GPU benchmarking.
5) Multiprocessor benchmarking.


REQUIREMENTS
------------

I tested it on:

  OS: Win2000 / XP
  CPU: 1xP3@800 / 2xP3@866 / 1xAthlonXP@1433
  SVGA: GeForce3 / nForce420 / ATI Rage M3

Should run on most configurations.


ADVERTISING :)
--------------

If you like this program, please check JellyMark: http://www.sourceforge.net/projects/jellymark
OpenSource, of course.


BYE
---

Feel free to contact me (daniele.paccaloni@dylogic.com).
Please report any bug (via the project home page if possible).
Send me a P4 if you want SSE2 support (in general, send me X if you want X support).
And use FFFF as a benchmark, too (press 'b') !

                Daniele Paccaloni

