orbit trap

[JosLeys]

On 3D Kleinian groups see http://www.josleys.com/show_gallery.php?galid=346 and this article (in French!)  http://images.math.cnrs.fr/Les-ensembles-limites-de-groupes.html.

I have not been able to come up with a way of drawing these things using a DE. What I need to do is calculate the positions of the centers, and the radii of thousands of spheres.

[Jesse]

and now ?

now something completely different 

Orbit trap did not worked as expected, to bad.

But volumetric light should be also a good option for more variety in images, but this is also much work...

does anyone know a replacement for the trigonometric polar coordinate mapping for the volumetric lightmap?

Because this is for CPU the current bottleneck as it seems, for every little step a arctan2 and arccos calculation slows it very much down 

So i thought there might be an alternative mapping technic to transform a fullsphere vector into a 2d map, the reverse transformation can be more time consuming because it is only performed once for each pixel.
Hmm, for partly maps (lightsource is in far distance), the function becomes more flat anyways...

[hobold]

So i thought there might be an alternative mapping technic to transform a fullsphere vector into a 2d map

Maybe cube mapping?

http://en.wikipedia.org/wiki/Cubemap

[Syntopia]

So i thought there might be an alternative mapping technic to transform a fullsphere vector into a 2d map, the reverse transformation can be more time consuming because it is only performed once for each pixel.
Hmm, for partly maps (lightsource is in far distance), the function becomes more flat anyways...

What about simply using lookup-tables for the acos and atan?

You could also precalculate two 2D textures, indexed the x and y component of a (normalized) ray direction. Since the z-component only is determined up to a sign, you would need two maps, one for positive z, and one for negative z. But I'm not sure how distorted this transformation is.

Maybe cube mapping? http://en.wikipedia.org/wiki/Cubemap

Also a good suggestion, since they probably introduce less distortion. I just checked, and you don't need trigonometry to lookup in these - there is a nice example of (CPU) cubemaps here: http://www.codermind.com/articles/Raytracer-in-C++-Part-III-Textures.html

[Jesse]

Yes, cube mapping looks nice..

i think the optimal solution would be to calculate the needed viewing frustrum for the lightsource into the scene and compute a rotation matrix to center it to one side of the cube.
In case the frustrum is below 90 degrees this cubes side could be stretched by a factor, and in case bigger 90 degrees you could calculate the needed fractions of the surrounding cube sides, so you dont have to calculate more than needed.

[ericr]

you want to do things for rendering fractal as Incendia EX  for example ?
that is it.
ericr


MC render is SUBLIME

[makc]

there is very simple atan approximation (Pi / 2) * x / (1 + abs(x)) - fast but nowhere near precise. for something more precise, check this out:

Code:

        public static function atan2(y:Number, x:Number):Number {
            var sign:Number = 1.0 - (int(y < 0.0) << 1)
            var absYandR:Number = y * sign + 2.220446049250313e-16
            var partSignX:Number = (int(x < 0.0) << 1) // [0.0/2.0]
            var signX:Number = 1.0 - partSignX // [1.0/-1.0]
            absYandR = (x - signX * absYandR) / (signX * x + absYandR)
            return ((partSignX + 1.0) * 0.7853981634 + (0.1821 * absYandR * absYandR - 0.9675) * absYandR) * sign
        }

[Jesse]

there is very simple atan approximation (Pi / 2) * x / (1 + abs(x)) - fast but nowhere near precise. for something more precise, check this out:

Code:

        public static function atan2(y:Number, x:Number):Number {
            var sign:Number = 1.0 - (int(y < 0.0) << 1)
            var absYandR:Number = y * sign + 2.220446049250313e-16
            var partSignX:Number = (int(x < 0.0) << 1) // [0.0/2.0]
            var signX:Number = 1.0 - partSignX // [1.0/-1.0]
            absYandR = (x - signX * absYandR) / (signX * x + absYandR)
            return ((partSignX + 1.0) * 0.7853981634 + (0.1821 * absYandR * absYandR - 0.9675) * absYandR) * sign
        }

Thank you, i might find some use for it.
Since the memory usage for the map, a lookup table as Syntopia mentioned would have done it here also, the speedup for a arccos LUT was very good as i tested it...
already changed to cubemap now.

[David Makin]

Just a small point relating to the Kleinians - it struck me quite awhile ago that one way to at least create something similar using DE is to use escape-time IFS - one needs something that produces circles or spheres (e.g. z^2+0) plus appropriate linear transforms.
So far I've only tried it in 2D and did this very simple example:



http://makinmagic.deviantart.com/art/Pure-Julia-IFS-123685891

Thinking about it one could of course also use the base object + IFS method (as per Dragon trees) to get the same result if you just want spheres As in:



http://www.fractalforums.com/index.php?action=gallery;sa=view;id=13260

But with spheres instead of cylinders.

I realise there are no spirals in the above but that just needs the addition of some rotations

[ericr]

only on example Chaospro 4.0
very simple to do with it