A good beginner's tutorial can actually be found in the `official' Povray manual (Online text version).
When people first start to model in Povray (or other raytracers for that matter), they often have a naive conception of its lighting model, which is usually too optimistic. A mistake I've seen several people (including myself) make is trying to give the environment some nice secondary lighting by modelling a `floor-lamp' type light source. The idea is to have the light of a light source reflect off a couple of surfaces before entering the rest of the scene, and/or by having it pass through some semi-transparent material. Unfortunately, this does not quite work out. Here's an example:
The light source is closed in by two cut-out sphere objects, so that no light can directly enter the scene without bouncing off one of the objects. The objects' reflective properties are set to maximum, yet the scene remains pitch dark. The only thing you see is the lamp itself, and its reflection in the shiny floor.
image_map pigment with the
filter all feature. The example below (source) is self-explanatory:
Just how far does Povray's transparency model go? Let us try to place some more interesting objects in the scene:
Another nice feature is combining transparent textures with area_light. This was used for the following stained-glass scene (source):
Underwater scenes might be modelled quite effectively using raytracing. Fog
can be used to simulate the way the water absorbs light. The ripples in the
water's surface could be done using textures that vary the surface's
transparency (as we know now, it can't be done using refraction effects). The
following scene (source was done by overlaying
several ripples textures with rgbf (colour filters):
We would like to set the ior value (refraction index) of the
water. However, we can't give the water an interior because fog won't work
when the camera is inside a non-hollow object. How to do air bubbles then?
Very simple: set their ior to a value less than 1.
Ambient lighting is a `kludge' that is meant to model light that is produced
through diffuse reflection. When an object should receive a significant amount
of light through diffuse reflection of light from the objects around it, it
will turn up too dark in a raytracer, because a raytracer doesn't model this.
The ambient setting is meant to compensate for this. An ambient
value greater than zero results in the object giving off some light of its
own. Ambient light looks very boring: the light level that the camera sees is
the same across the entire object. The object is not treated as a light source
either: it does not light other objects.
This changes when we turn on radiosity. Now, the ambient light is treated as a light source: the ambient light level of one object determines the ambient light level of the objects around it. The other types of lighting are unaffected. How does this work? The surface of each object is divided into patches. From each patch, a number of random rays are cast into the scene. The ambient values of the bits of surface that the rays hit are added up to form the colour and relative light level of the patch. The overall light level of the object is still determined by its ambient value. If the ambient value is either 0 or 1, radiosity has no effect.
An example scene (source) is given below. Note that the right wall has ambient value 1, and serves as a light source.
In the left picture, the only thing in the scene that indicates that it was actually done by a raytracer is the transparent reflective surface of the table. The right picture clearly shows the effects of radiosity. The right wall itself is unaffected, while it actually lights the other walls in different colours. A quite nice effect is the shadow under the table. There's something odd about the table though: the part of the floor that is visible through the table's surface is unaffected! Apparently, radiosity only models the surfaces that are directly visible by the camera.
Another raytrancer / radiosity renderer that is specially made for radiosity is Radiance. It is however not really made for defining scene specifications by hand, since it doesn't have a real programming language.
While L-systems may look quite beautiful, they are in fact very simple to generate. It is perhaps not very surprising that they turn up so easily in nature. Computers, too, are good at fractals. Your C precompiler can do them. For instance, you can use this small script to generate L systems. Here are a couple of example scenes:
In case you're interested, you might want to take a look at real L-parsers.
Download the visualisation software: data-refinery-0.9
(more information coming soon)