POV-Ray

The current official version of POV-Ray is 3.7. This version introduces:

• support for symmetric multiprocessing (SMP), to allow the renderer to take advantage of multiple processors
• support for high-dynamic-range imaging (HDRI), including the OpenEXR and radiance file formats
• improved bounding using BSP trees

Some of the main introduced features of the previous release (3.6) are:

• extending UV mapping to more primitives
• adding 16- and 32-bit integer data to a density file
• improving 64-bit compatibility

In July 2006, Intel Corporation started using the beta version of 3.7 to demonstrate their new dual-core Conroe processor due to the efficiency of the SMP (symmetric multiprocessing) implementation.

Rendering of the Venn diagram of four spheres created with constructive solid geometry, or CSG. The source is on the description page of the image.

Some colored dice rendered in POV-Ray. CSG, refraction and focal blur are demonstrated.

POV-Ray, in addition to standard 3D geometric shapes like tori, spheres, and heightfields, supports mathematically defined primitives such as the isosurface (a finite approximation of an arbitrary function), the polynomial primitive (an infinite object defined by a 15th order or lower polynomial), the julia fractal (a 3-dimensional slice of a 4-dimensional fractal), the superquadratic ellipsoid (an intermediate between a sphere and a cube), and the parametric primitive (using equations that represent its surface, rather than its interior).

POV-Ray internally represents objects using their mathematical definitions; all POV-Ray primitive objects can be described by mathematical functions. This is different from many computer programs that include 3D models, which typically use triangle meshes to compose all the objects in a scene.

This fact provides POV-Ray with several advantages and disadvantages over other rendering and modeling systems; POV-Ray primitives are more accurate than their polygonal counterparts: objects that can be described in terms of spheres, planar surfaces, cylinders, tori, and the like, are perfectly smooth and mathematically accurate in POV-Ray renderings, whereas polygonal artifacts may be visible in mesh-based modeling software. POV-Ray primitives are also simpler to define than most of their polygonal counterparts, e.g., in POV-Ray, a sphere is described simply by its center and radius; in a mesh-based environment, a sphere must be described by a multitude of small connected polygons (usually quads or triangles).

On the other hand, script-based primitive modeling is not always a practical method to create certain objects, such as realistic characters or complex man-made artifacts like cars. Those objects can be created first in mesh-based modeling applications such as Wings 3D and Blender, and then they can be converted to POV-Ray's own mesh format.

The following is an example of the scene description language used by POV-Ray to describe a scene to render. It demonstrates the use of a background colour, camera, lights, a simple box shape having a surface normal and finish, and the transforming effects of rotation.

POV-Ray image output based on the script

 #version 3.6;
// Includes a separate file defining a number of common colours
 #include "colors.inc"
 global_settings { assumed_gamma 1.0 }

// Sets a background colour for the image (dark grey)
 background   { color rgb <0.25, 0.25, 0.25> }

// Places a camera
// direction: Sets, among other things, the field of view of the camera
// right: Sets the aspect ratio of the image
// look_at: Tells the camera where to look
 camera       { location  <0.0, 0.5, -4.0>
                direction 1.5*z
                right     x*image_width/image_height
                look_at   <0.0, 0.0, 0.0> }

// Places a light source
// color: Sets the color of the light source (white)
// translate: Moves the light source to a desired location
 light_source { <0, 0, 0>
                color rgb <1, 1, 1>
                translate <-5, 5, -5> }
// Places another light source
// color: Sets the color of the light source (dark grey)
// translate: Moves the light source to a desired location
 light_source { <0, 0, 0>
                color rgb <0.25, 0.25, 0.25>
                translate <6, -6, -6> }

// Sets a box
// pigment: Sets a color for the box ("Red" as defined in "colors.inc")
// finish: Sets how the surface of the box reflects light
// normal: Sets a bumpiness for the box using the "agate" in-built model
// rotate: Rotates the box
 box          { <-0.5, -0.5, -0.5>,
                <0.5, 0.5, 0.5>
                texture { pigment { color Red }
                          finish  { specular 0.6 }
                          normal  { agate 0.25 scale 1/2 }
                        }
                rotate <45,46,47> }

The following script fragment shows the use of variable declaration, assignment, comparison and the while loop construct:

POV-Ray image output based on the script

 #declare the_angle = 0;

 #while (the_angle < 360)
 	box {   <-0.5, -0.5, -0.5>
 		<0.5, 0.5, 0.5>
                texture { pigment { color Red }
                          finish  { specular 0.6 }
                          normal  { agate 0.25 scale 1/2 } }
 		rotate the_angle }
 	#declare the_angle = the_angle + 45;
 #end

Official modifications to the POV-Ray source tree are done and/or approved by the POV-Team. Most patch submission and/or bug reporting is done in the POV-Ray newsgroups on the news.povray.org news server (with a Web interface also available). Since POV-Ray's source is available there are unofficial forks and patched versions of POV-Ray available from third parties; however, these are not officially supported by the POV-Team.

Official POV-Ray versions currently do not support shader plug-ins.[14] Some features, like radiosity and splines are still in development and may be subject to syntactical change.

POV-Ray 3.6 is distributed in compiled format for Mac, Windows and Linux. Support for Intel Macs is not available in the Mac version, but since Mac OS X is a version of Unix the Linux version can be compiled on it.

The 3.7 versions with SMP support are officially supported for Windows and Linux. Unofficial Mac versions for v3.7 can be found.[15]

POV-Ray can be ported to any platform which has a compatible C++ compiler.

Originally, POV-Ray was distributed under its own POV-Ray License. Namely, the POV-Ray 3.6 Distribution License[16] and the POV-Ray 3.6 Source License,[17] which permitted free distribution of the program source code and binaries, but restricts commercial distribution and the creation of derivative works other than fully functional versions of POV-Ray.

Although the source code of older versions is available for modification, due to the above 3.6 and prior license restrictions, it was not open source or free software according to the OSI or the FSF definition of the term. This was a problem as source code exchange with the greater FOSS ecosystem was impossible due to License incompatibility with copyleft licenses.

One of the reasons that POV-Ray was not originally licensed under the free software GNU General Public License (GPL), or other open source licenses, is that POV-Ray was developed before the GPL-style licenses became widely used; the developers wrote their own license for the release of POV-Ray, and contributors to the software worked under the assumption their contributions would be licensed under the POV-Ray 3.6 Licenses.

In 2013, with version 3.7, POV-Ray was relicensed under the Affero General Public License version 3 (or later).[18] Thus POV-Ray is since then free software according to the FSF definition and also open source software according to the Open Source Definition.