Atmosphere Interaction

By default light sources will interact with an atmosphere added to the scene. This behaviour can be switched off by using the atmosphere keyword inside the light source statement.

light_source { ... atmosphere off }

Atmospheric Attenuation

Normally light coming from light sources is not influenced by fog or atmosphere. This can be changed by turning the atmospheric attenuation for a given light source on. All light coming from this light source will now be diminished as it travels through the fog or atmosphere. This results in an distance-based, exponential intensity falloff ruled by the used fog or atmosphere. If there is no fog or atmosphere no change will be seen.

Section 7.5.7
Object Modifiers

A variety of modifiers may be attached to objects. Transformations such as translate, rotate and scale have already been discussed. Textures are in a section of their own below. Here are three other important modifiers: clipped_by, bounded_by and no_shadow. Although the examples below use object statements and object identifiers, these modifiers may be used on any type of object such as sphere, box etc.


The clipped_by statement is technically an object modifier but it provides a type of CSG similar to CSG intersection. You attach a clipping object like this:

object { My_Thing clipped_by{plane{y,0}} }

Every part of the object My_Thing that is inside the plane is retained while the remaining part is clipped off and discarded. In an intersection object the hole is closed off. With clipped_by it leaves an opening. For example the following figure shows object A being clipped by object B.

An object clipped by another object.

clipped_by may be used to slice off portions of any shape. In many cases it will also result in faster rendering times than other methods of altering a shape.

Often you will want to use the clipped_by and bounded_by options with the same object. The following shortcut saves typing and uses less memory.

object { My_Thing bounded_by { box { <0,0,0>, <1,1,1> } } clipped_by { bounded_by } }

This tells POV-Ray to use the same box as a clip that was used as a bounds.


The calculations necessary to test if a ray hits an object can be quite time consuming. Each ray has to be tested against every object in the scene. POV-Ray attempts so speed up the process by building a set of invisible boxes, called bounding boxes, which cluster the objects together. This way a ray that travels in one part of the scene doesn't have to be tested against objects in another, far away part of the scene. When large a number of objects are present the boxes are nested inside each other. POV-Ray can use bounding boxes on any finite object and even some clipped or bounded quadrics. However infinite objects (such as a planes, quartic, cubic and poly) cannot be automatically bound. CSG objects are automatically bound if they contain finite (and in some cases even infinite) objects. This works by applying the CSG set operations to the bounding boxes of all objects used inside the CSG object. For difference and intersection operations this will hardly ever lead to an optimal bounding box. It's sometimes better (depending on the complexity of the CSG object) to use a bounded_by statement with such shapes.

Normally bounding shapes are not necessary but there are cases where they can be used to speed up the rendering of complex objects. Bounding shapes tell the ray-tracer that the object is totally enclosed by a simple shape. When tracing rays, the ray is first tested against the simple bounding shape. If it strikes the bounding shape the ray is further tested against the more complicated object inside. Otherwise the entire complex shape is skipped, which greatly speeds rendering.

To use bounding shapes, simply include the following lines in the declaration of your object:

bounded_by { object { ... } }

An example of a bounding shape:

intersection { sphere { <0,0,0>, 2 } plane { <0,1,0>, 0 } plane { <1,0,0>, 0 } bounded_by { sphere { <0,0,0>, 2 } } }

The best bounding shape is a sphere or a box since these shapes are highly optimized, although, any shape may be used. If the bounding shape is itself a finite shape which responds to bounding slabs then the object which it encloses will also be used in the slab system.

CSG shapes can benefit from bounding slabs without a bounded_by statement however they may do so inefficiently in intersection, difference and merge. In these three CSG types the automatic bound used covers all of the component objects in their entirety. However the result of these intersections may result in a smaller object. Compare the sizes of the illustrations for union and intersection in the CSG section above. It is possible to draw a much smaller box around the intersection of A and B than the union of A and B yet the automatic bounds are the size of the union of A and B regardless of the kind of CSG specified.

While it is almost always a good idea to manually add a bounded_by to intersection, difference and merge, it is often best to not bound a union. If a union has no bounded_by and no clipped_by POV-Ray can internally split apart the components of a union and apply automatic bounding slabs to any of its finite parts. Note that some utilities such as raw2pov may be able to generate bounds more efficiently than POV-Ray's current system. However most unions you create yourself can be easily bounded by the automatic system. For technical reasons POV-Ray cannot split a merge object. It is probably best to hand bound a merge, especially if it is very complex.

Note that if bounding shape is too small or positioned incorrectly it may clip the object in undefined ways or the object may not appear at all. To do true clipping, use clipped_by as explained above. Often you will want to use the clipped_by and bounded_by options with the same object. The following shortcut saves typing and uses less memory.

object { My_Thing clipped_by{ box { <0,0,0>,<1,1,1 > }} bounded_by{ clipped_by } }

This tells POV-Ray to use the same box as a bounds that was used as a clip.


POV-Ray by default assumes that objects are made of a solid material that completely fills the interior of an object. By adding the hollow keyword to the object you can make it hollow. That is very useful if you want atmospheric effects to exist inside an object. It is even required for objects containing a halo (see "Halo" for details).

In order to get a hollow CSG object you just have to make the top level object hollow. All children will assume the same hollow state except their state is explicitly set. The following example will set both spheres inside the union hollow

union { sphere { -0.5*x, 1 } sphere { 0.5*x, 1 } hollow }

while the next example will only set the second sphere hollow because the first sphere was explicitly set to be not hollow.

union { sphere { -0.5*x, 1 hollow off } sphere { 0.5*x, 1 } hollow }


You may specify the no_shadow keyword in an object to make that object cast no shadow. This is useful for special effects and for creating the illusion that a light source actually is visible. This keyword was necessary in earlier versions of POV-Ray which did not have the looks_like statement. Now it is useful for creating things like laser beams or other unreal effects.

Simply attach the keyword as follows:

object { My_Thing no_shadow }


Some of POV-Ray's objects allow you to choose between a fast but sometimes inaccurate root solver and a slower but more accurate one. This is the case for all objects that involve the solution of a cubic or quartic polynomial. There are analytic mathematical solutions for those polynomials that can be used.

Lower order polynomials are trivial to solve while higher order polynomials require iterative algorithms to solve them. One of those algorithms is the Sturmian root solver.

The following list shows all objects for which the Sturmian root solver can be used.

  lathe    (only with quadratic splines)
  prism    (only with cubic splines)

Next Section
Table Of Contents