Welcome to Fractal Forums

Within weeks of the discovery of the Mandelbulb, first realtime GPU tracers were made. Some based on DirectX/HLSL, some on CUDA/Optix, others on OpenGL/GLSL.
I haven't seen any Mandelboxes rendered in realtime yet. Is it because there is no easy code samples out there that show how to apply the formula?

Christian

EDIT: for the controls I want spaceship like navigation, so I can zoom trough it as if it was a frakkin' death star. ;)

I've been asking the same question,  I ended up with a real-time mandelbox  running in evaldraw  from a script done by knighty.

I just this very minute tried it for the first time... so hang on....

In this video of a 4k demo by Still, it seems that the mandelbox is calculated in real time, so probably on the GPU

http://www.youtube.com/watch?v=CZ6YhJNnou8&feature=related

I've made one, but a lot of work is still to be done. No ambient occlusion, no precomputing, no fullscreen, awkward controls... :dink:
http://www.ms.mff.cuni.cz/~kadlj3am/big/boxplorer/ (http://www.ms.mff.cuni.cz/~kadlj3am/big/boxplorer/)

I get the following error. My machine is XP.

OpenGL 2.0 shader functions unavailable.

You need a fairly recent card with support for OpenGL 2.0 (I think you need at least a NVIDIA Geforce 8xxx or ATI Radeon HD 2xxx because of branching in the shaders).

I've only tested it on ATI Radeon HD 4850 and NVIDIA Geforce 9300M GS.

Hey, I downloaded a  mandelbulb gpu based one on my iphone!

http://angisoft.de/Angisoft/Angisoft.html (http://angisoft.de/Angisoft/Angisoft.html)

It really is fast enough and interactive for having a lot of fun exploring.

I'm AMAZED this is on a mobile  !!

Seriously if you can do this using OPENGL ES ,   it should be possible to get near realtime on a PC also !

Has anyone got code lying about that uses GPUs?   I guess there must be stuff lying about from the demo scene.

It would be great of people here hubbed together to write some stuff like this and share the code.

Surely GPU rendering should be a revolution in fractal rendering and exploration?

Jesus mother of christ....   This is TOTALLY AMAZING.   I still can't get over it.
I'm running a ATI HD 3850.   It can't do OPENCL/CUDA and stuff like that which I thought you needed for real time raytracing.
I considering this card out of date as it wouldn't run any new OPENCL/CUDA like stuff!

would be great if you could post a commented version of the src, would really like to get my head around what
is going on here!

What is better   Nvidia or ATI for all this new GPU rayracing stuff?

That is very hard to answer right now. On the one hand, Nvidia has been promoting general purpose computing on the GPU for a longer time than ATI/AMD, so Nvidia's drivers and development systems are much more polished and usable. On the other hand, Nvidia's latest hardware (the 400 series, "Fermi") is plagued by silicon fabrication issues. So right now, Nvidia's high end GPUs draw more power, are more expensive, and slightly slower than ATI/AMD's high end offerings.

Theoretically, Nvidia has an advantage in double precision calculations, but their mainstream products are throttled in this regard. The Radeons meet or slightly exceed GeForce performance in practice for a significant majority of workloads.

OpenCL drivers and development support still has more rough edges than CUDA. But I expect OpenCL to eventually "win", because it doesn't lock people in to a single hardware source. In the extreme case, OpenCL programs can be run without a GPU, on the ordinary processor(s), albeit with much lower performance.

I've had a quick look and PRICE vs PERFORMANCE,  ATI/AMD winds hands down.  So since I have a fixed budget,
I really have no choice but go for a XFX 5850.

My feelings are in agreement with yours OpenCL, long term is going to win, as it's platform/hardware/brand agnostic, like OpenGL.
The drivers will catch up soon enough.
STILL  I had no bloody idea it was such an exciting time for graphics, all this horsepower is going to mean real-time graphics exploration.

I mean it's a dream come true, if you go back to the days, running fractint on a 286 and waiting hours to render one fractal!
I'm really excited about fractals all again - I think the mandelbox/bulb really got me going. I can't wait to get the fast hardware to really do more real-time.

have fun with it, be sure to try out subblues pixelbender skript for rendering the bulb as your first act on having a new card
mandelbrot calculations are really simple implemented on those cards, and damn fast ( it is 2 years ago that i had a fullscreen ( 1920x1280 ) mandelbrot renderer of my own ... nowadays it should just blow ! )

Thanks, Rrrola.

It ist my first experience with a GPU based fractal renderer and it makes fun.

The best: If I put the fragment.glsl and vertex.glsl script in the same directory as Boxplorer.exe, i can change you Mandelbox shader.

wow it works blazingly fast, thank you for that this is good source for screensaver/demo coding ;)
do you mind if we spread the link, or add it to the fractalforums.com downloads section ?
perhaps opening up an open source development this usually boosts early stages of a project

Wow, comes with source code. *Hug!*

Christian

I only have a crappy ATI X600 but thought I would try the program anyway - figuring it may use software emulation, and I get:

[Program:]
 Link successful. The GLSL vertex shader will run in software due to the GLSL fragment shader running in software. The GLSL fragment shader will run in software - unsupported language element used.

In stderr.txt but the program actually locks up (with an empty window) and I have to end task it :(

I agree to Trifox – this is a very good example to start a own shading algorithm. It would be cool,  if there is an place in this forum, where users share simple shaders for some of the discussed 3D fractals here.

// I have replaced the Mandelbox Formula by the 3DJulia formula to test the influence of different
// parameters of the strange spirals in real time.

// Distance estimation is removed, so it should be easy to define own fractals in computeDistAndColors().
// This function has only to decide, if a given point is inside or outside to fractal. Additional
// a surface color can be defined.

// You have to save this text in a file with name fragment.glsl and put it in the same directory as
// Boxplorer.exe

// Pressing q or w change a spiral parameter (fine tuning of this parameter is done with a and s).
// All other keys are used like the original shader.


// Mandelbox shader by Rrrola
// Original formula by Tglad
// - http://www.fractalforums.com/3d-fractal-generation/amazing-fractal
// Changed to formula 21 (3DJulia) by trafassel

// Camera position and direction.
varying vec3 eye, dir;

// Interactive parameters.
uniform float scale,  // Fractal scale. Controls the appearance of the Mandelbox.
  min_dist,           // Distance at which sphere tracing stops.
  eps;                // Epsilon for surface normal approximation.
uniform int iters,    // Number of fractal iterations.
  max_steps;          // Maximum sphere tracing steps.

// some parameters to change
// the default formula uses para1 and para2
static float para1;
static float para2;
static float para3;
static float para4;
static float para5;
static float para6;
static float para7;
static float para8;



// Colors.
vec3 backgroundColor = vec3(0.25, 0, 0.5),
  glowColor = vec3(0, 0.75, 1),
  objectColor1 = vec3(1, 0, 0.15),
  objectColor2 = vec3(1, 0.66, 0),
  specularColor = vec3(1, 1, 0.75);


// Compute the "distance" from `pos` to the Mandelbox.
// Because the is no default distance estimation for arbitrary functions,
// this method has only to know, if p is inside or outside the iterative set. 
// retVal[0]>0 outside, retVal[0]<0 inside the fractal
// retVal[1], retVal[2], retVal[3] Components of the surface color
// retVal[1]=red
// retVal[2]=green
// retVal[3]=blue
vec4 computeDistAndColors(vec3 p) {
  // a little bit scaling to get a nice start view
  p=0.4*p;
  vec4 retVal=vec4(0,0,0,0);
  vec3 col=vec3(0,0,0);

  // Preparation:
  float xx=p.x*p.x;
  float yy=p.y*p.y;
  float zz=p.z*p.z;
  float r=sqrt(xx+yy+zz);

  float myI=0.0;
  int myIters=5;
  float lastr=0.0;
  float bailoutr=300.0;
  float myScale=scale/4.0;


  for (int i=0; i<iters; i++) {
    p.x=2.0*p.x*p.y*p.z;
    p.y=yy-para1*(xx+zz);
    p.z=zz-para1*(xx+yy);
    xx=p.x*p.x;yy=p.y*p.y;zz=p.z*p.z;

    p.y=2.0*p.x*p.y*p.z;
    p.x=xx-para1*(yy+zz);
    p.z=zz-para1*(xx+yy);

 // Julia Seed
    p.z+=para2;

    xx=p.x*p.x;yy=p.y*p.y;zz=p.z*p.z;
    float tempDist=xx+yy+zz;

    float r=sqrt(tempDist);

    if(i>2&&i<iters-1) {
        col[0]+=xx/tempDist;
        col[1]+=yy/tempDist;
        col[2]+=zz/tempDist;
     }


    if(r>bailoutr) {
      retVal[0]=1.0;
      if(i>1) // near the surface
        retVal[0]=2.0;
      retVal[1]=col[0];
      retVal[2]=col[1];
      retVal[3]=col[2];
      return retVal;
    }
    lastr=r;
  }
  retVal[0]=-1.0;
  retVal[1]=col[0];
  retVal[2]=col[1];
  retVal[3]=col[2];

  return retVal;
}


// Gets the distance from pos to the fractal.
// <0, if pos is inside
float d(vec3 pos) {
  return computeDistAndColors(pos)[0];
}



// Get true, if the point p is element of the fractal.
bool isInSet(vec3 p) {
  return (d(p)<=0.0);
}


// Moves p in direction, such that p is near the surface.
// Distance ist the maximal distance from p to the surface of the fractal.
vec3 fix(vec3 p,vec3 direction,float distance) {
  float myDist=distance;
  float minDist=0.000001;
  bool inSet=true;
  float mult=1.0;
  while(myDist>minDist) {
   inSet=isInSet(p);
   if(inSet)
   mult=-myDist;
   else mult=myDist;
   p+=mult*direction;
   myDist*=0.5;
  }
  return p;
}


// Gets the normal of the surface on point p.
// using: eps,dir
vec3 getNormal(vec3 p,float dist) {
  vec3 dp = normalize(dir);
  vec3 tempVec=vec3(dir.y,-dir.z,dir.x);
  vec3 dir1=normalize(cross(dir,tempVec));
  vec3 dir2=normalize(cross(dir,dir1));
  vec3 p1=fix(p+20.0*eps*dir1,dp,dist);
  vec3 p2=fix(p+20.0*eps*dir2,dp,dist);
  return normalize(cross(p1-p,p2-p));
}


// custom function to set the type of the changable parameter.
// The color of the background shows the type of parameters.
// To change the tape, the user has to press 'c' or 'v'.
void setPara() {
  backgroundColor = vec3(0, 0, 0);
  //int dType=(max_steps-50);
int add=180;
int dType=(max_steps-add);
if(dType<0)
 dType=-1;
if(dType>add)
 dType=-2;

switch(dType) {
case -1:
para1=1;
para2=1;
para3=1;
para4=1;
para5=1;
para6=1;
para7=1;
para8=1;
backgroundColor = vec3(1, 0, 0);
break;

case -2:
para1=1;
para2=1;
para3=1;
para4=1;
para5=1;
para6=1;
para7=1;
para8=1;
backgroundColor = vec3(1, 1, 1);
break;


case 0:
para1=0.17*(scale+min_dist);
backgroundColor = vec3(0, 0, 0);
glowColor = vec3(0, 0, 0);
break;

case 1:
para1=0.17*(scale+min_dist);
backgroundColor = vec3(0.25, 0, 0);
break;

case 2:
para1=0.3*scale;
para2=min_dist;
backgroundColor = vec3(0, 0.25, 0);
break;

case 3:
para4=scale+min_dist;
backgroundColor = vec3(0.25, 0.25, 0);
break;

case 4:
para5=scale+min_dist;
backgroundColor = vec3(0, 0.25, 0.25);
break;

case 5:
para6=scale+min_dist;
backgroundColor = vec3(0.25, 0,0.25);
break;

case 6:
para7=scale+min_dist;
backgroundColor = vec3(0.25, 0.25, 0.25);
break;

case 7:
para8=scale+min_dist;
backgroundColor = vec3(0.5, 0.5, 0);
break;

}

}


// This method is called for each pixel in the output bitmap.
void main() {
 
  setPara();
  vec3 p = eye, dp = normalize(dir);

  // Using different accuracy for forground and background.
  float dist = 0.03;
  float mainDist=0.02;
  float frontDist=0.01;
  float backDistMult=1.05;
  int steps;
  int my_max_steps=160;
  int front_steps=20;
  int background_steps=110;
  bool isOutside=true;
  float estimatedDist=dist;

  // Intersect the view ray with the Fractal.
  for (steps=0; steps<my_max_steps; steps++) {
    if(isOutside) {
      if (steps<front_steps)
         dist=frontDist;
      else
       if (steps<background_steps)
         dist=mainDist;
       else
         dist*=backDistMult;     
    }
    if (isInSet(p)) {
      if(dist>mainDist) {
         p -= dist * dp;
         isOutside=false;
         my_max_steps+=10;
         dist=mainDist;
      } else {
        isOutside=false;
        break;
        }
     }
    p += dist * dp;
  }

 
  // Moves p to the surface of the fractal.
  p=fix(p,dp,dist);
  vec3 normal=getNormal(p,dist);

  // Draw the surface.
  vec3 color = specularColor;
  if (!isOutside) {
    // This time, we need the surface color.
    vec4 mycol=computeDistAndColors(p);
    normal=normalize(normal);
    float frontLight=dot(normal,dp);
    frontLight*=frontLight;
    color[0]=mycol[1];   color[1]=mycol[2];   color[2]=mycol[3];
    color=normalize(color);
    color=frontLight*(0.5*color+vec3(0.5,0.5,0.5));
    }

  if(steps>my_max_steps)
    steps=my_max_steps;
  if(isOutside)
    gl_FragColor = vec4(backgroundColor, 1);
  else // surface gets a 'glow', if the corresponding points are far away.
    gl_FragColor = vec4(mix(color, glowColor, float(steps)/float(my_max_steps)), 1);
}

Boxplorer 1.02 released.
http://www.ms.mff.cuni.cz/~kadlj3am/big/boxplorer/ (http://www.ms.mff.cuni.cz/~kadlj3am/big/boxplorer/)

What's new: speedups, parameter files, screenshots, fullscreen mode, ambient occlusion, anti-aliasing, better controls, user parameters, Linux compatibility and colors that don't hurt your eyes. ;-)

I'll post some high-quality screenshots later.

I have used Boxplorer and it is amazingly fast. However when I use it with a bigger window than the default, malware has been detected by my AVG internet security program. Details of what AVG detected are enclosed in the attached JPG file. What is causing AVG to detect a malware threat? It it possible to use Boxplorer without the malware? Are there any other programs which render the Mandelbox using the GPU?

- Shadows a system executable: That's probably because of the name (it's similar to Explorer.exe).
- Small executable: It's small because it uses the Windows C runtime, SDL and OpenGL - most of the functionality is provided from outside. (And I would argue that a 29 kB exe isn't small at all. :dink:)
- Executes from the filesystem: Probably because it doesn't need to be installed in Program Files.
- Injects code: I don't know what this means. Do the previous versions of Boxplorer cause this too?

This is a false alarm (AVG is known to cause these on intro-like programs). All in all, if you don't trust this exe, the full source code is available in the directory /src and you can compile it yourself (I'm using MinGW, a Windows port of the GCC compiler).

OK, here are the promised screenshots. More are on my page (http://rrrola.wz.cz/downloads.html#effects (http://rrrola.wz.cz/downloads.html#effects)) or my deviantART account (http://rrrola.deviantart.com/ (http://rrrola.deviantart.com/)).

Very promising. :) Thanks man.

Sweet little program!  :)

I've hacked it up a bit to add a form of stereoscopic rendering and path recording/playback+save imgs.
(http://www.fractalforums.com/mandelbulb-renderings/46-inch-stereoscopic-display/msg21092/#msg21092 (http://www.fractalforums.com/mandelbulb-renderings/46-inch-stereoscopic-display/msg21092/#msg21092))

Would you care for diffs back or do you have a svn/git repository somewhere?
Also made it compile using the free (yay!) visual C++ 10 express, mostly a bunch of project/solution setup pain  :-\

And very cool that it builts on Linux. Only -lm -lglut -lSDL need to be specified to link against.
You will need freeglut and the SDL devel headers.

Find attached changes i made to add two forms of stereoscopic rendering.
Add --overunder or --xeyed to the commandline.
Make sure to use the provided vertex.glsl since i added some parameters to pass to the videocard..

btw, does anyone have a regular mandelbulb.glsl that works nicely with boxplorer? Other interesting fragment.glsl types?

This weekend I ran this on a Geforce GTX 460 on OpenSuSE Linux 11.2 and it was quite a sight.
To get the resolution to 1920x1200 (that of my LCD monitor), I edited the last.cfg file and
passed last.cfg as a command line argument on each successive start.

It delivered quite good frame rates still, enough for interactive navigation.

Christian

Nice software and clever optimization to the distance estimation formula. :) Thanks Rrrola.

Mandelbox with {scale~-1.1, minRad~0} is really interesting. The number or iterations must be about 100.

The secondary branch count follows the Fibonacci sequence:
(http://www.ms.mff.cuni.cz/~kadlj3am/big/boxplorer/screenshots/20100803_133010.jpg)

Kleinian group:
(http://www.ms.mff.cuni.cz/~kadlj3am/big/boxplorer/screenshots/20100803_005309.jpg)

Trees with Menger sponges:
(http://www.ms.mff.cuni.cz/~kadlj3am/big/boxplorer/screenshots/20100803_004355.jpg)

Hyperbolic circle packing (sort of):
(http://www.ms.mff.cuni.cz/~kadlj3am/big/boxplorer/screenshots/20100803_003700.jpg)

And the corner of the box:
(http://www.ms.mff.cuni.cz/~kadlj3am/big/boxplorer/screenshots/20100803_005155.jpg)

I'm uploading hi-res images (8192x6144) to http://www.ms.mff.cuni.cz/~kadlj3am/big/boxplorer/screenshots/hires/ (http://www.ms.mff.cuni.cz/~kadlj3am/big/boxplorer/screenshots/hires/) if anyone is interested.

very nice indeed! <me starting up other computer to start exploring/>

Very nice indeed!
Thank you also for the formula improvements, the minmax clipping works with SSE very good too  :)

I avoided scalings near to +/-1 because of inaccuracies, but with a minimum iterationcount of 20 and a maximum of 160 or so it works also with M3D   :angel1:

Very nice find!

I tried to replicate in M3D but although I came across some nice surprises, the box looks flat (with very nice 2D patterns on it) and in the few holes I could not find such beauties.

@Jesse I saw your pictures, would you mind sharing the .m3p?

Is ok.

Experimenting with hybrids (Mandelboxes with different parameters for each iteration), but distance estimation is being a jerk. :fiery:

Mr. Golem says hello:
(http://www.ms.mff.cuni.cz/~kadlj3am/big/boxplorer/screenshots/20100909_225549.jpg)

Thanks Jesse! I finally managed to find a cave entrance by myself :) If I find something really nice, I will render a picture, but what's really cool with this -1.1 box is the 2D patterns on its surface, like trees and spirals...

Some folk asked me about building using visual C++. Find attached a (hopefully) self-contained setup that should build using nmake.
Also has the --xeyed, --overunder, --record and --playback options I played with a while ago. And a commented out, failed, half-assed attempt at adding bulb rendering in fragment.glsl

Rrrola, still around? What license you put this stuff out under?

> What license you put this stuff out under?

Let's make it an ISC licence.

---

Copyright 2010 Jan Kadlec <rrrola@gmail.com>

Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted, provided that the above
copyright notice and this permission notice appear in all copies.

THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

@Rrrola: it would be nice to see the fragment for mr. Golem..  :)
@Marius: could you please explain what to do with these files?
should be compiled?  :embarrass:
thanks in advance