Welcome to Fractal Forums

I've finally finished the PixelBender implementation of the 3D Mandelbulb. The PixelBender scripts run on the GPU when used in Photoshop CS4 or the Adobe PixelBender Toolkit (which you can download for free from here: ). It runs fast enough for interactive exploration and parameter tweaking at low resolutions and then for final output at 2k dimensions with 9x super sampling takes about 5-10 seconds to render on my iMac NVIDIA 8800GS graphics card.
The PixelBender .pbk files can also be used directly in After Effects where every parameter can be keyframed and animated. AfterEffects can't use the GPU so everything is rendered via the CPU, which is significantly slower.

Finally, I've also ported the script to a GLSL shader which is implemented as a patch in QuartzComposer, where everything can be animated in realtime. This will run at about 15fps @640x480 resolution. The animations on my site were rendered with this.

Read more and download the scripts.

(http://farm3.static.flickr.com/2537/4186490580_c915acc878.jpg)

(http://www.subblue.com/assets/0000/4548/spiky8_large.jpg)
 (http://www.subblue.com/projects/mandelbulb)

great, thank you for publishing that !

just had a quick test ... the )(()=$(=)$ pixelbender tells me that my geforce gts 250 is not able to execute the prgram ... :(

perhaps i have to reboot after installation of pixelbender ?!

Having an up to date nVidia driver installed? possibly a DirectX update, too? (not sure if Adobe would use OpenGL over DirectX - for cross platform compatibility OpenGL sure is the better choice)

FANTASTIC Mr Subblue, just tried it on my old MacBook Pro, got it down on it´s knees, but I got my first mandelbulb rendering!! :D

Amazed by the skills of you people here!!!!

Been lurking this forum since I saw an article about the skytopia site ( I know, mr twinbee... special thanks to you too for making me find all these new places) I made my first mandelbrot with the help of my computerfriends in the eighties, and now I'm back! ;-) Thanks to you lot!

Regards

Johan

THE IMAGE... Not a beauty, but I am happy just to been able to do it (after just 20 minutes tinkering), thanks!

(http://farm3.static.flickr.com/2485/4187676286_6ac85d6cd9_o.jpg)

Thanks guys :)

I actually fixed a little bug with some graphics cards. I've updated the scripts so try downloading them again (http://www.subblue.com/assets/0000/4684/Mandelbulb.zip).

Trifox: I'm not sure why PixelBender is doing that. Does it do it with the example filters or just mine in particular?

i get an division by zero error, when hitting "run" in the toolkit  :sad1:

@sub it is a driver problem ...

i fixed the default value for phong shading, it caused a division by zero error for me ... ;(

ok, the problem was that i had the boinc ( seti@home..., rosetta@home... ) running, which was blocking the gpu,
now it is rendering in less than a second !

great, i have a base to play with ... muahar, thanxs for publishing it, if i make any senseful changes, i will send you a copy!

And it is such a great environment for prototyping things quickly. And much more hardware and platform independent than solutions like CUDA. Pixelbender even rendered this on older Geforce 6800 class hardware (albeit slowly).

This code has the potential to become the "reference" implementation for experiments with distance-estimated 3D fractals.

I am delighted that also the negative powers render nicely (Mandeliers, etc). However when one iterates a negative power in a voxel based system, one will get a hole in an otherwise solid block. So what one sees with DE methods might actually be the inverted fractal or some other artefact of raymarching from the *interior* of the set towards the outside (for which the distance estimation formula based on Hubbard-Duady would be incorrect).

hi there,

how wonderful this little skript is ...

i have managed to include an alternation mechanism, i am now about to implement different formulas,
before i go sleep, i will send you my "hacked"skrip to pm , so many thanks !

Trifox, the ring structure variation is particularly interesting.

I found this little gem when exploring the juliabulb varation at -6.5 power with low bailout:
(http://farm3.static.flickr.com/2687/4173080210_44c28f0d4c.jpg) (http://www.flickr.com/photos/subblue/4173080210/sizes/o/)

i have send you the alternate formula, check your private messages here on the forum  O0

What kind of alternations are we talking about here. Switching formulas during the iteration? Changing the rotations, etc?

 alternating seed values ( for julia ) and/or powervalues for both ...

formula alternating is my next experiment, the problem is to keep the distance estimator working ...  :alien:

This is so incredible, I have to disturb this thread again!
I am totally new to this but this filter made me learn to render mandelbulbs in five minutes, you should all try it!
One more image, just to show what you who are no experts could do after 24 hours with subblues pixbenderscript:
(on an rather old laptop with ATI Radeon X1600)

(http://farm3.static.flickr.com/2680/4189402789_223dcae992_b.jpg)

Thanks again for the script!

MANDELBULBS TO THE PEOPLE!!! ;-)

trifox and subblue, nice images, give me another 24 hours...  ::)

Currently it is possible to switch between "Juliabulb" and "Mandelbulb" with a checkbox. Here is an idea:

How about allowing the user to freely "morph" between a Juliabulb and a Mandelbrot by linearly interpolating between the "C" value of the mandelbrot (which is the original Z coordinate) and the fixed constant of the Juliabulb. So one could introduce a slider value range 0 to 1. I do not know if this morph would look any good at all, but it's worth an attempt IMHO ;)

It's simple enough to do-

Add a new parameter:

and then in the DE method change the line:
to
Some interesting animations could be created using this technique. For instance, setting the Julia_c parameters to 0, 0, 0 then morphing creates the Mandelbulb out of a perfect sphere.

Kind of wondering what such a Morph parameter would do to a 2D mandelbrot set. hmm..

Also I am not having another (stupid?) idea. Increasing the max iteration count is only possible in integer steps... Or not? But I would like to make pefectly smooth animations from 0 iterations to infinity.

Assume you want to render 2.5 iterations on a power 8 bulb. So what I suggest is:

First iteration: Z^8+C, Second iteration: Z^8+C, Third iteration: Z^4+C.
Rendering 2.25 iterations would make the third iteration Z^2+C
We simply scale the last iteration's exponent by the fraction of the iteration we need to perform last. So you get a float slider also for iteration count. Heheh. Genius.

Okay there is an issue. Suppose you want to render 2.0 iterations. That would make the (hypothetical) third iteration Z = Z^0+C = Z/|Z|+C.   Somehow though we need this to become Z = Z.

And as a final point for today I would like to raise the question why the power 2 Mandelbulb rendered with the Pixelbender does not look similar to any of Bugman's renders as shown in the "Summary of 3D Mandelbrot Set Formulas" thread in the Theory forum. I am undecided whether this is an implementation bug or some other parameter that I have overlooked.

the parameter makes clearly sense,
i have written a ultrafractal formula, which simply blends between the z values of two independent formuals, works like a charme, and
the best is, you have smooth iteration between so to say, any desired other fractal ( some glitches by sign changes can happen though )

That can be done, though it's easier just to use solid at given DE threshold and gradually change the value, to do it for smooth iteration then I would use a DE threshold of zero but for each step on a ray calculate the smooth iteration value and use that as the "solid" condition - obviously gradually increasing the smooth iteration threshold to approach the Set.
Note that for lower iteration counts and/or higher DE thresholds then a binary search to find the exact boundary when solid is hit would be required for results without "stepping".

Hmmm, I also find it odd that the 8-degree looks different from the one on Daniel Whites site:

(http://www.skytopia.com/project/fractal/new/q85/Power8side-small.jpg)

Here is a detail of one i did with this script:

(http://farm3.static.flickr.com/2776/4191736553_607436cf1d.jpg)

The "mini-bulbs" are more "hollow"?

Different formulas? Or is it just more detail in Daniels version?

J

I think your version is more detailed. the more you increase iteration count, the more the mini-bulbs become hollow and dusty.

I think your version is more detailed. the more you increase iteration count, the more the mini-bulbs become hollow and dusty.
[/quote]

OK, cool... How many iterations has somebody done on this thing, I did 20, just curious what it looks like when iterations gets close to infinity (or very high at least ;-)

J

OK, cool... How many iterations has somebody done on this thing, I did 20, just curious what it looks like when iterations gets close to infinity (or very high at least ;-)

J
[/quote]
The more you zoom the more you'll need high iteration count. Unlike in the 2D M-set, it is better not to too increase iteration count too much otherwise the picture looks like dust.

My formula renders solid based on distance estimate rather than based on iteration value and I normally render with maxiter set to 400 and "solid" being decided only by the distance estimate threshold.
So far I only really checked what iteration count were being reached once on a deeper zoom and on that the 400 limit was exceeded on a few pixels, though that could just have been due to slight over-stepping. I think that particular render the actual iteration counts for most of the solid pixels did exceed 100.

OK, I´m not so well updated on rendering techniques, Studio Strata, a hundred years ago... but I get some of it David ::)
How did the minibulbs look in that 100/400 iteration image? Solid or hollow?
(Getting a bit OT here I fear... reckon this has been discussed before, will try to find a thread...)

I guess they look exactly how you'd expect them to look - the bulbs have bulbs have bulbs have bulbs......
Here's a deep zoom:

http://www.fractalforums.com/gallery/?sa=view;id=1043 (http://www.fractalforums.com/gallery/?sa=view;id=1043)

Note that rendering using small DE threshold is much better than using render based on high iteration value because you don't get the problem of no detail in some areas with too much detail in others that you get using solid based on iteration.

The 'quick' .pbk version renders Mandelbulbs that are symmetrical top and bottom, whereas the other version renders bulbs that are asymmetric and closer to Bugman's versions.

@David, I don't know why you stick with the value of 400 iterations. In most of my videos, including the tower zoom, I never had to set more than 20 iterations. I rather play with solid threshold.

Could you please make a (re)post of your definite DE method. Currently it is buried in an overlong (albeit very interesting thread). I tried reading the entire thread, but got somewhat detoured on Marcus Aurelius etc, and didn't quite get through it all before bedtime...

 

Great explanation David, thanks! Now I get the DE treshold mportance.

J

When using the DE threshold as the "solid" condition then I use a high iteration value to ensure that all the points are "solid" based on the DE value and not based on the max iter value - using a lower iteration value can mean that some points get set as "solid" even without being close enough to "inside".
Note that the number of iterations actually used in this case is determined entirely by the DE threshold.

http://www.fractalforums.com/3d-fractal-generation/true-3d-mandlebrot-type-fractal/msg7812/#msg7812 (http://www.fractalforums.com/3d-fractal-generation/true-3d-mandlebrot-type-fractal/msg7812/#msg7812)

With this change to the way the "dists" array is used when checking a new step distance:

              if j<=miter
                if step<dists[j]
                  repeat
                    dists[j] = step
                    j = j + 1
                  until j>miter || step>=dists[j]
                  if j>miter
                    mdist = step
                  endif
                else
                  step = dists[j]
                endif
              else;if j>miter
                miter = miter + 1
                if step>mdist
                  step = mdist
                endif
                while miter<j
                  dists[(miter=miter+1)] = mdist
                endwhile
                dists[j] = step
              endif

Where j is the iteration count for the current step, mdist is the absolute minimum found on the ray so far and miter is the maximum iterations used anywhere on the ray so far.

Hmm so I definitely feel more at home in the "Quick" version of the script, as it generates the same output as the Optix raytracer version I've been working on earlier.

In the "full" version Mandelbulb.pbx I did notice that the definitions of theta and phi seem reversed

      float r    = length(z);
      float th = atan(z.y, z.x);
      float ph = asin(z.z / r);

So theta is now in the x,y plane and phi is the rotation upwards and downwards. Hmm...

They do look a lot different... This could explain why...
Also, I am running out of decimals ;) Trying to do some deep zooming to see how fractal this thing is, I think it is very fractal so far, but with only 3 decimals for camera positioning it gets impossible to zoom longer in after a while, I can force 4 decimals but then the images gets very pixelled..

I am so happy with your script Subblue, but if you ever do something more on it this is my wishlist:

More 0,0000000000decimals

Ability to "slice" the brot. (want to see the inside!!!!

Thanks again for the script!!!!/ Johan

Johan, the biggest limitation is due to PixelBender (and many GPUs) not supporting double floats. Very quickly you can get to the numerical limit for standard floating point numbers - you'll start seeing lots of pixel noise. The PixelBender interface either in the IDE or Photoshop also rounds up very small parameter numbers (a real pain!). I added the cameraPositionFine to get around some of this, so get as close as you can with the main cameraPosition slider and then use the cameraPositionFine slider to get that bit closer.

The ability to slice the Mandelbulb is also on my list of things to implement. I've been adding a few other features, like alternative formulas and alternating seed/power values that Trifox has suggested. I'll be releasing an update soon.

Well I suspected this, guess I have to use another program to get really deep, but I like your script so much, easy to change things in. (Found your Droste effect-filter yesterday, cool!)

Looking forward to your updates, the best images I have done so far with your script is here:
http://mandelwerk.deviantart.com/gallery/
I hope you think it is a good thing that I give you cred and link to your site on all images, if not I remove the links.

Regards
J

Been using this script  almost every day since I got it, LOVE it!  :)

Now I have a few questions I have compared the exponent 2 renderings from this script with bugmans list of formulas:
http://www.fractalforums.com/theory/summary-of-3d-mandelbrot-set-formulas/

Here is the "MandelbulbQuick" script, it looks a lot like the positive z version (as cbuchner1 pointed out for me) :
(http://farm3.static.flickr.com/2759/4343729146_f56fab19bc.jpg)

(http://www.fractalforums.com/index.php?action=dlattach;topic=2081.0;attach=1024;image)

But more confusing is the pure "Mandelbulb" script it produces this:

(http://farm5.static.flickr.com/4005/4343729216_b4399668be.jpg)

A bit similar to Daniel Whites, but distorted somehow?

(http://www.fractalforums.com/theory/summary-of-3d-mandelbrot-set-formulas/?action=dlattach;attach=1021;image)

Could there be some fault in the formula as cbuchner1 pointed out earlier in this thread?

http://www.fractalforums.com/mandelbulb-implementation/mandelbulb-ray-tracing-plugin-for-photoshop-aftereffects-and-quartzcomposer/msg10204/#msg10204

My math is not good enough to tell  ???

Regards
Johan

I've been playing around with these shaders too.

If you look at the end of powN() function in MandelbulbQuick, and change sin(zo) to -sin(zo), the second order Mandelbulb looks a lot like the picture above, though I think there are still artifacts (I can see some disconnected prongs at the horizontal line of symmetry).

Hi Andy, I tried your formula change, and you are right it looks more like "The original".

I've been avidly creating animations with the Mandelbulb Quartz Composer patch - and loving it! Following Tom's suggestion on subblue.com, I purchased the Quartz Crystal utility that allows you to export animations as Quicktime movies or image sequences. I've been having some trouble, and wonder if anyone else is having similar experiences, and might have some suggestions. My animations render ok when I do them at low res, say 480 pixels. But higher than that, like 1024, the exporter starts dropping frames. And when I do it at really high res, 2048x2049 - which is what I need to be able to render, then it garbles the images that survive and drops about half of them.
I wonder - Am I just pushing the program too hard, and it's hopeless, or am I perhaps doing something wrong. I'd love to hear if anyone's succeeded in outputting hires animations with this setup. Thanks!

I've found QuartzCrystal can actually lock up my machine if I try to push the renders too high. Ideally it would be better if a single frame could be rendered as a series of 'buckets' but I haven't figured out how to implement that in QC yet. However, I am busy working on a version of the plugin that will offer native GPU acceleration directly within AfterEffects - pretty much a complete rewrite of the original PixelBender version. I'm currently using it in production at the moment to create a music video and hope to have it released within the next month or so.

Would be nice to see your mandelbulb (?) music video when it is official Subblue...

J