>   Try with the example at wikipedia:
> http://en.wikipedia.org/wiki/Image:Total_internal_reflection.jpg

I really have now only spheres and planes. Boxes next.

>   If you are bruteforce-rendering anyways, using these limited lighting
> models kind of becomes moot. They were created precisely for
> non-bruteforce rendering because bruteforce rendering was unfeasible.
> Now that you are bruteforce-rendering, there's no need to use them. You
> can use realistic BRDFs.

I don't know. I think these are different things. Brute force helps to create
every lighting effect which depends on light bouncing multiple times. BRDF, on
the other hand, just represents the way light reflects. So they address
different problems. But it is true that both should be handled and taken into
account in a good renderer.

>   In principle a BRDF is quite simple: It's a function which takes an
> incoming direction vector and an outcoming direction vector as (const)
> parameters, and returns a factor for each color component between 0.0
> and 1.0. That's it. Its usage is equally simple: When you have
> calculated a ray which intersects a surface and want to reflect that ray
> to some direction, you shoot that reflected ray and then multiply the
> color returned by that ray with the factor returned by the BRDF of that
> surface. This will be the color returned by the original incoming ray.

I think that is not the best way to implement it. Better way is to use a ray
distribution function that generates rays distributed according to BSDF. Now I
use cosine weighted function to create random rays at diffuse surface. This
minimizes useless rays and gives faster results - but is unbiased. And I create
pure specular rays at specular surface - no need to create other rays and give
them weight 0. The result is identical but faster. There are good functions for
different glossy surfaces also.

So basically I'm using certain ideal BSDF's but "ideal" is not necessarily
"physically possible"...

Post a reply to this message