## Blueberry hipersnowflake details

2010-05-01 at 13:16 | Posted in Computer path | Leave a commentTags: 3D, art, C++, engine, fractal, maths, procedural, programming, radiosity, ray tracing, raydiant, raytracing, realtime, render

A few zoomed details from the ‘blueberry hipersnowflake’ could be useful to assert the quality of the full resolution render. See it at deviantart. Thanks to my wife Maria for those images:

## Intimacity lab tests

2010-04-22 at 16:39 | Posted in Computer path | Leave a commentTags: 3D, art, C++, engine, fractal, maths, procedural, programming, radiosity, ray tracing, raydiant, raytracing, realtime, render

I keep experimenting with Intimacity set. So many possibilities and so much fun. These are just a few samples. Also a coil of mirror spheres I found to be nice. It’s a big help to be able to walk in real time trough all this scenarios using the Raydiant engine then just take ‘photographs’ of the views you like. Furthermore, even I’m the one who built these scenario, it’s procedural so the exploration really satisfies my curiosity. The render speed of the Raydiant engine greatly facilitates the process.

## Intimacity inner workings

2010-04-18 at 12:03 | Posted in Computer path | 2 CommentsTags: 3D, art, C++, fractal, procedural, radiosity, ray tracing, realtime

I’m currently working on a new procedural render called Intimacity (accent should be put on the ‘a’ letter). It is a maze-city-like structure generated using the procedural API of the Raydiant engine. These are test renders of the city that shows a hint of what the basic idea is. I find these geometric-non-periodic-but-simetric arrangement very soothing and comforting. It is based on Alberto’s Maze function (see this post if you wish).

## Improved reeditions with Raydiant

2010-04-13 at 17:08 | Posted in Computer path | 5 CommentsTags: 3D, art, C++, fractal, procedural, radiosity, ray tracing, realtime

As part of the initial work phase for Raydiant some scenes from the Raydiosity engine have been rerendered at very high resolution (30 to 64 megapixel) so they can be printed at large sizes (http://albertoven.deviantart.com/gallery/). Here is a preview (these are scaled down versions, still far better quality than achieved with the old Raydiosity engine):

## Real time Raydiant

2010-02-15 at 18:08 | Posted in Computer path | Leave a commentTags: 3D, art, C++, fractal, global illumination, path tracing, procedural, radiosity, ray tracing, realtime

Ok, now that Raydiant is working I’m using it to render some images developed with the previous Raydiosity engine. But this time in high resolution. So they can be printed in large formats. The results are being posted at albertoven.deviantart.com. In the process the realtime interactive no precalc full global illumination capabilities are fun to use. Of course the quality and resolution of the render is reduced consequently, but even so the feeling of those walks is something enjoyable. Here are various examples of real time walks, some with global illumination, other in raytraced preview mode (in very decent resolution and frame rate) and some details from the new 25 megapixel ‘fold the bar three leaf clover’.

## Monolith Coil revamped

2010-01-23 at 17:35 | Posted in Computer path | Leave a commentTags: 3D, art, C++, procedural, ray tracing

At last I’m reaching the point where Raydiant engine is fully usable. First thing I’ve done is a new very similar revamped version of my ‘monolith coil’ picture, but this time at 8000×6000 resolution (that would be 48 megapixel) so is printable with high quality at big sizes. It is already uploaded at albertoven.deviantart.com/art/monolith-coil-150027873. With the Raydiant engine it has been a nice 39 hours render. Main differences with the old original version is It has some subtle wall texture, better postprocessing (Raydiant includes this treatment) and far faster rendering time.

## Raydiant: chasing the rainbow

2009-12-14 at 19:42 | Posted in Computer path | 2 CommentsTags: 3D, C++, density distribution, fractal, game, procedural, ray tracing

This is the first sample render of Raydiant using spectral sensitive materials. In this case some crystal triangular monoliths are responsible for the rainbowish thingy. I’ve developed a spectral pathtracing method, no photons are traced from light sources (no photon mapping), so light sources can be arbitrarily numerous and heterogeneous and render goes just even faster. Total internal reflection is also modeled, hence the secondary rainbows apparently going against the unique light source. I’ve spent long time staring at every different light effect on each zone of this particular render, I like them. So from now on Raydiant is a spectral pathtracer. The monoliths are made of glass with refraction index 1.4 to 1.6 for all the range of visible light. I’m working on speeding it up by a factor of 20 times and it’s looking good. The second image with square monoliths is another test posted for aesthetic reasons.

## Raydiant: realtime mutithreaded global illumination

2009-11-08 at 11:04 | Posted in Computer path | Leave a commentTags: 3D, C++, density distribution, fractal, game, global illumination, path tracing, procedural, ray tracing

The global illumination tracer module has been finally completed/debugged and is working. So the new ideas applied to Raydiant engine about realtime steradian controled stem count to improve performance are now proved to be useful. Also the generic multithreaded tracer than can hold any other tracer inside (like the global illumination one) and transparently clone it and make it work at any number of threads simultaneously without synchronization penalties is completed and debugged. The result is that now you can interactively move yourself around in a synthetic scenario with true realtime global illumination in a i7. This opens far-reaching possibilities: games that look as if you where there is one I’m really attracted to. Also now that Fermi platform from Nvidia is here the Raydiant engine can be compiled at one of those 512 CPU cards and see what happends… . Because there is no precalcs the scene lights can be instantly moved around. And any number of ligths can be put at a secenario with no performance penalty, in fact is the inverse. On some of these screenshots the new light dispersion capability of the Raydiant engine can be clearly appreciated.

## Raydiant: custom probability distribution

2009-11-07 at 11:11 | Posted in Computer path | 1 CommentTags: 3D, C++, density distribution, fractal, game, procedural, ray tracing

It was very useful to be able to transform a constant normalized random distribution (same probability for every number between 0 and 1) into another one with personalized density distribution. This has been used to create materials choosing photon bouncing directions. Also used on objective depth of field effects of different types. This is the way I did it (and really enjoyed deducing this one):

- Lets suppose we have a random generator with a density probability distribution : D(x)=1 for all 0<=x<1, and lets call ‘r’ the random numbers generated by this distribution.

- We want to get another density probability distribution called E(x), of course definite integral of E(x) between x=0 and x=1 must be exactly 1.

- Lets call ‘t’ to the random numbers generated by E(x) distribution.

- I found the relationship between r and t is: r = definite integral of E(x) between x=0 and x=t. This is to say the area defined between E(x) and the horizontals axis between x=0 and x=t must be exactly r.

- So just substitute your E(x) and solve the equation for t.

- Applied example 1: find a random distribution that applied to a radius and given uniform random angles gives a homogeneous surface distribution at the plane inside a radius 1 circle:
- Solution: t = sqrt(r/pi)

- Applied example 2: find a random distribution that applied to a radius and given uniform random angles gives a homogeneous surface distribution at the plane inside a washer of radius r0 and r1 with r0<r1:
- Solution: t = (-b+sqrt(b^2+2ar))/a with a = (2(r1-r0))/(r0+r1) and b = 1-(r1-r0)/(r0+r1)

- As exercise: can you calculate ‘t’ for a random distribution which is completely lineal between x=0 and x=1?

These are some screen shoots of custom random distributions made by my wife María with the same Raydiant engine:

## Raydiant: Random generators

2009-11-07 at 10:09 | Posted in Computer path | 3 CommentsTags: 3D, C++, fractal, game, procedural, pseudorandom, random generator, ray tracing

I find delightful the art of pseudorandom number generation. A bunch of generators has been tested before choosing one for the Raydiant engine. Some of them have been found to be not so random by the simple method of drawing random points in an accumulation buffer. These are the bad sheep (see the screen shoots just to be sure):

- Park-Miller “minimal standard” 31 bit pseudo-random number generator, implemented with David G. Carta’s optimization: with 32 bit math and without division.

- Lehmer random number generator. For more details see: “Random Number Generators: Good Ones Are Hard To Find” by Steve Park and Keith Miller, Communications of the ACM, October 1988.

- Concatenation of following two 16-bit multiply with carry generators: x(n) = a*x(n-1)+carry mod 2^16 and y(n) = b*y(n-1)+carry mod 2^16. Number and carry packed within the same 32 bit integer. Pass all of the tests in Marsaglia’s “Diehard” battery of statistical tests.

- Combination of a Multiply with carry generator and a simple multiplicative generator. Returns x(n) + z(n) where x(n) = x(n-1) + x(n-2) mod 2^32 and z(n) = 30903 * z(n-1) + carry mod 2^16. Pass all of the tests in Marsaglia’s “Diehard” battery of statistical tests.

On the other hand there were other generators that didn’t show their true predictive nature and insisted on appearing as true random numbers:

- ANSI C pseudorandom number generator.
- Mersenne Twister pseudorandom number generator.
- Robert Jenkins’ IBAA generator. Pass all of the tests in Marsaglia’s “Diehard” battery of statistical tests.
- Combination of lagged Fibonacci generator and a multiply with carry generator. Returning x(n)+y(n) mod 2^32 where x(n)=x(n-99)*x(n-33)mod2^32, x’s odd and y(n)=30903*y(n-1)+carrymod2^16. Pass all of the tests in Marsaglia’s “Diehard” battery of statistical tests.
- A Combination of 2 multiple recursive generators. Has parameters for 3 different combos. Source: Pierre

* L’Ecuyer, “Good Parameter Sets for Combined Multiple Recursive Random Number Generators.” Operations Research, vol.47 no.1 (1999), pp.159–164. Pass all of the tests in Marsaglia’s “Diehard” battery of statistical tests. - Combination of 3 Tausworthe generators — assumes 32-bit integers, Source: Pierre L’Ecuyer, “Maximally

Equidistributed Combined Tausworthe Generators”. Mathematics of Computation, vol.65, no.213(1996), pp203–213. Pass all of the tests in Marsaglia’s “Diehard” battery of statistical tests. Strong theoretical backing so far. - Combination of 4 tausworth generators — assumes 32-bit integers, Sources: Pierre L’Ecuyer, “Tables of

Maximally-Equidistributed Combined LFSR Generators.” Mathematics of Computation, vol.68, no 225(1999), pp.261–269. Pass all of the tests in Marsaglia’s “Diehard” battery of statistical tests. Strong theoretical backing so far.

Other merits considered to choose the perfect one were fastness of set seed operation, low memory usage, length of period and of course random number generation performance. And the winner is…

- Combination of a shift-register sequence on a 32-bit vector, a linear congruential generator, and a multiply with carry sequence. Returns y+x+z where y(n) = b xor (b<<5), b = a xor (a>>17), a = y(n-1) xor (y(n-1)<<13)), x(n) = 69069*x(n-1)+1mod2^32 and z(n) = 2*z(n-1)+z(n-2)+carry mod 2^32. The period is > 2^127. Extremely high quality, extremely fast, ultra fast set seed, 32 bit random numbers. Pass all of the tests in Marsaglia’s “Diehard” battery of statistical tests.

These are the bad sheep, to appreciate the defects is imperative you see them at full size and 1 pixel per texel zoom. A couple billion points have been accumulated on each one:

Blog at WordPress.com.

Entries and comments feeds.