A finite object has a bounded size: it fits in a box. This page lists every one of them that the POV-Ray 3.8 parser knows, with its syntax, each keyword and its default, how the surface is found and what the parser checks. The shapes that extend to infinity or are defined by a function or an image (plane, poly, quadric, isosurface, parametric, height_field) are on Infinite and implicit objects. The triangle meshes are on Meshes. Union, merge, intersection and difference are on Constructive solid geometry. The words that can follow the arguments of any object (transformations, textures, flags) are on Object modifiers.
What all objects share
| Rule | Meaning |
|---|---|
name { ... } | Every object is a keyword followed by a block in braces: the arguments of the shape come first, then the modifiers. |
| Commas | The commas between arguments are optional. A trailing comma after the last point of a point list is accepted. |
| Vector arguments | A single number where a vector is wanted is repeated for every component, so box { -1, 1 } is the cube from <-1,-1,-1> to <1,1,1>. A 2D vector argument (<x, y>) is read where a shape asks for points of a curve. |
| Object identifier first | If the first thing in the block is the name of a declared object, the parser copies that object, reads the modifiers after it and skips the rest of the syntax of the shape. sphere { Gear rotate y*20 } is a copy of Gear, whatever shape Gear was. |
| Modifiers | After the arguments (and the shape's own keywords) come the object modifiers. Their full list is on Object modifiers. This page names the modifiers that only some shapes accept: open, sturm and hierarchy. |
| Final check | After the block the shape computes its data. If that fails, the parser reports Inconsistent object parameters. as a possible error. |
The objects at a glance
Solid means the object has an inside, so it can be used in the inside tests of CSG. A patch has no inside. open, sturm and hierarchy are accepted only where the table says yes; elsewhere they are a parse error (Keyword 'sturm' cannot be used with this object.).
| Object | Arguments | Solid | open | sturm | hierarchy |
|---|---|---|---|---|---|
box | two corners | yes | no | no | no |
sphere | centre, radius | yes | no | no | no |
cylinder | two end points, radius | yes (capped) | yes | no | no |
cone | two end points with a radius each | yes (capped) | yes | no | no |
torus | major and minor radius | yes | no | yes | no |
disc | centre, normal, radii | half-space (see notes) | no | no | no |
lemon | two end points with a radius each, inner radius | yes (capped) | yes | yes | no |
ovus | two radii | yes | no | yes | no |
superellipsoid | exponents E and N | yes | no | no | no |
lathe | spline type, points | yes | no | yes | no |
prism | spline type, sweep type, heights, points | yes (capped) | yes | yes | no |
sor | points | yes (capped) | yes | yes | no |
text | font, string, thickness, offset | yes | no | no | no |
polygon | number, points | no | no | no | no |
triangle | three corners | no (patch) | no | no | no |
smooth_triangle | three corners with normals | no (patch) | no | no | no |
bicubic_patch | type, steps, 16 points | no (patch) | no | no | no |
blob | threshold, components | yes | no | yes | yes |
sphere_sweep | spline type, spheres | yes | no | no | no |
julia_fractal | 4D parameter, items | yes | no | no | no |
Box, sphere, cylinder, cone, torus and disc
box
box { <corner1>, <corner2> [modifiers] }An axis-aligned box between two opposite corners. The parser compares the corners one axis at a time and swaps the two values where the first is larger, so the corners can be given in any order. The surface is found by clipping the ray against the three pairs of planes of the box. A box turned by a rotation is no longer axis aligned in the scene, but it stays a box in its own space.
sphere
sphere { <centre>, radius [modifiers] }A ball. The ray test solves a quadratic equation. Scaling a sphere by different factors on the axes gives an ellipsoid.
cylinder
cylinder { <end1>, <end2>, radius [open] [modifiers] }| Item | Default | Meaning |
|---|---|---|
<end1>, <end2> | required | the centres of the two end faces; the axis runs between them |
radius | required | the radius along the whole length |
open | closed | leaves the two end faces off, so the object is a tube with no inside |
The side is a quadratic surface and each end is a flat disc. A closed cylinder is solid. An open one has no end faces, so a ray that enters through an end meets no surface there; the parity of the hits then no longer says what is inside, and the object gives wrong results in CSG.
cone
cone { <end1>, radius1, <end2>, radius2 [open] [modifiers] }| Item | Default | Meaning |
|---|---|---|
<end1>, radius1 | required | the centre and the radius of the first end face |
<end2>, radius2 | required | the centre and the radius of the second end face |
open | closed | leaves the end faces off |
A truncated cone (a frustum). A radius of 0 makes a point. The radii may be different or equal; equal radii give the same surface as a cylinder. The parser does not check the sign of the radii. As with the cylinder, the side is a quadratic surface, the ends are discs, and an open cone should not be used in CSG.
torus
torus { major, minor [difference | intersection | merge | union] [sturm] [modifiers] }| Item | Default | Meaning |
|---|---|---|
major | required | the distance from the centre to the middle of the ring |
minor | required | the radius of the ring's cross-section |
difference, intersection, merge, union | union | what happens in the self-intersecting spindle region of a torus whose minor radius is larger than its major radius (below) |
sturm | off | use the slower and more accurate root solver for the 4th order equation |
The ring lies in the x-z plane around the y axis. The ray test solves a 4th order polynomial. A negative major or minor radius is accepted with a warning and inverts the object; write inverse instead. When major is smaller than minor the object is a spindle torus. Its four modes act like the CSG operations on the two overlapping halves of the surface: union keeps the whole surface and the spindle is inside; merge hides the surface inside the spindle; difference cuts the spindle volume away so it is outside; intersection keeps only the spindle volume. On a torus that is not a spindle torus, intersection gives a "possible parse error" and an object that cannot be seen, and the other three words have no effect.
disc
disc { <centre>, <normal>, outer_radius [, inner_radius] [modifiers] }| Item | Default | Meaning |
|---|---|---|
<centre> | required | the middle of the disc |
<normal> | required | the direction the disc faces; the parser makes it a unit vector |
outer_radius | required | the radius of the edge |
inner_radius | 0 | the radius of a round hole in the middle (a ring); it is read only if a number follows the outer radius |
A flat, infinitely thin circle or ring. A ray is intersected with the plane and the hit point is checked against the two radii. The inside test is not that of a thin sheet: the object counts every point behind the plane (the side opposite the normal) as inside, however far from the centre, as a plane does. Use a short cylinder if you want a flat solid.
box { <-1, -0.5, -0.5>, <1, 0.5, 0.5> pigment { rgb <1, 0.5, 0> } }
sphere { <0, 2, 0>, 0.75 pigment { rgb <0, 0.5, 1> } }
cylinder { <0, 0, 0>, <0, 1, 0>, 0.5 open pigment { rgb 1 } translate x*3 }
cone { <0, 0, 0>, 1, <0, 2, 0>, 0 pigment { rgb <0, 1, 0> } translate -x*3 }
torus { 1.5, 0.3 rotate x*90 pigment { rgb <1, 0, 0> } }
disc { <0, -2, 0>, y, 2, 0.5 pigment { rgb 0.8 } }Lemon, ovus and superellipsoid
lemon
lemon { <end1>, radius1, <end2>, radius2, inner_radius [open] [sturm] [modifiers] }| Item | Default | Meaning |
|---|---|---|
<end1>, radius1 | required | one end point and the radius of the circle at that end |
<end2>, radius2 | required | the other end point and its radius |
inner_radius | required | the radius of the circular arc that joins the two end circles; the surface is that arc turned around the axis |
open | closed | leaves the end faces off |
sturm | off | the more accurate root solver |
A lemon is like a cone whose side bulges: the arc of the inner radius connects the end circles. With the smallest allowed inner radius the surface is a section of a sphere; larger values give the inner part of a self-crossing torus. Either end radius may be 0. The parser rejects a negative radius (All radii must be positive). If the inner radius is below the minimum for the two end radii and the distance between the ends, it is raised to that minimum and a warning gives the value.
ovus
ovus { bottom_radius, top_radius [radius r] [distance d] [precision p] [sturm] [modifiers] }| Keyword | Value | Default | Meaning |
|---|---|---|---|
| (first number) | float | required | radius of the bottom sphere, centred at the origin; it must be above 0 |
| (second number) | float | required | radius of the top sphere, on the y axis; it must not be negative |
radius | float | twice the larger of the two radii | radius of the connecting torus arc |
distance | float | the bottom radius | distance between the two sphere centres; it must be at least the bottom radius |
precision | float | 1e-4 | tolerance of the root solver for the connecting part |
sturm | flag | off | the more accurate root solver |
An egg: two spheres joined by a smooth surface that is a trimmed lemon. The parser stops with an error if the connecting radius is smaller than half the sum of the bottom radius, the top radius and the distance. If the numbers give a connecting part of zero width, the ovus is replaced by one sphere and a warning says so.
superellipsoid
superellipsoid { <E, N> [modifiers] }A rounded box or cylinder from one 2D vector. It fills about the box from <-1,-1,-1> to <1,1,1>. <1, 1> is a sphere; values towards 0 make the corners and edges sharper. Both numbers must be above 0 (the parser does not check this; the manual gives it as a rule). The parser stores the exponents 2/E, E/N and 2/N for the three axes. The ray test searches numerically inside the bounding box, so very small values cause trouble and sturm is not accepted.
// a spindle torus (minor radius larger than major radius), cut open to show the spindle
difference {
torus { 0.5, 0.8 difference }
box { <-2, 0, -2>, <2, 2, 0> }
pigment { rgb <1, 0.6, 0.2> }
}
ovus { 1, 0.5 radius 1.5 distance 1.2 precision 0.0001 sturm pigment { rgb 1 } translate x*3 }
superellipsoid { <0.25, 0.25> pigment { rgb <0, 1, 0> } translate -x*3 }
lemon { <0, 0, 0>, 0.2, <0, 2, 0>, 0.2, 1.5 pigment { rgb 1 } translate -x*5 }Lathe, prism and sor
These three objects are built from a list of 2D points. A lathe and a sor turn the curve around the y axis; a prism sweeps it along the y axis. In all three the points are written as 2D vectors and the number of points comes first.
lathe
lathe { [linear_spline | quadratic_spline | cubic_spline | bezier_spline]
n, <r1, h1>, <r2, h2>, ... <rn, hn> [sturm] [modifiers] }| Item | Default | Meaning |
|---|---|---|
| spline type | linear_spline | how the points are joined (see the table of spline types below) |
n | required | the number of points that follow, all control points included |
| points | required | each point is <radius, height>: x is the distance from the y axis, y is the position along it |
sturm | off | the more accurate root solver |
The curve is not closed for you: join the last point to the first yourself if you want a closed shape. A lathe has no end caps, it is the surface the curve sweeps. The ray test solves a polynomial per segment: order 2 for linear, order 4 for quadratic and order 6 for cubic and Bezier segments.
| Spline | Fewest points | Segments | How the points are used |
|---|---|---|---|
linear_spline | 2 | n - 1 | straight lines between consecutive points |
quadratic_spline | 3 | n - 2 | each curve passes through two points; the point before the first one sets the slope; the last point is only a slope control |
cubic_spline | 4 | n - 3 | the first and last point are only slope controls |
bezier_spline | 4, and a multiple of 4 | n / 4 | points 1 and 4 of each group are the ends of a segment, points 2 and 3 are control points |
Checks for a lathe in a scene that declares version 3.8 or later: a point with a negative radius is an error (with a linear spline any point; with a quadratic spline any point but the first; with a cubic spline any point but the first and last; with a Bezier spline any end point of a segment). A Bezier control point with a negative radius gives a warning. In scenes that declare a version before 3.8, a negative radius on the first or last point (the last point only, for a quadratic spline) is only a warning. The error for too few cubic points mentions a "Prism", which is a wrong word in the message.
prism
prism { [linear_spline | quadratic_spline | cubic_spline | bezier_spline]
[linear_sweep | conic_sweep]
height1, height2, n, <x1, z1>, ... <xn, zn> [open] [sturm] [modifiers] }| Item | Default | Meaning |
|---|---|---|
| spline type | linear_spline | same four types as the lathe |
linear_sweep | this one | the curve keeps its size from one height to the other, so the walls are perpendicular to the x-z plane |
conic_sweep | off | the curve is scaled down along the sweep, so the walls are cone-like |
height1, height2 | required | the y coordinates of the two end faces; if the first is larger the parser swaps them |
n | required | the number of points, all control points included |
| points | required | each point is <x, z>: the curve lies in the x-z plane |
open | closed | leaves the two end faces off |
sturm | off | the more accurate root solver |
The spline type and the sweep type words can come in any order and any number, before the heights. One prism can hold several closed curves; where an even number of them overlap there is a hole. Fewest points: 3 for linear, 5 for quadratic, 6 for cubic, and a multiple of 4 for Bezier. For the quadratic and cubic splines the first point of each curve (and for the cubic spline also the last) is a control point that is not on the curve.
Closing: a curve is closed by repeating its first point at its end. With a linear spline the last curve is closed for you if you forget, with the warning Linear prism not closed. Closing it. With the other spline types an unclosed curve makes the prism degenerate: it is ignored, with the warning Prism not closed. Ignoring it. The caps are flat polygons; the sides use polynomials of order 2 (linear) to 3 (cubic and Bezier).
sor
sor { n, <r1, h1>, ... <rn, hn> [open] [sturm] [modifiers] }| Item | Default | Meaning |
|---|---|---|
n | required | the number of points; at least 4 |
| points | required | each point is <radius, height> |
open | closed | leaves the end caps off; do not use an open sor in CSG |
sturm | off | the more accurate root solver |
A surface of revolution: the curve through the points (a smooth cubic fit) is turned around the y axis. The first and last point only set the slope at the ends of the curve; there are n - 3 segments. Unlike a lathe, the curve must be a function: one radius for each height. The parser stops with Incorrect point in surface of revolution. if a radius is negative or if from the third point to the second to last the height does not go up from one point to the next. The test of a ray solves a cubic polynomial per segment, which is faster than the lathe.
lathe {
cubic_spline
6,
<0, 0>, <0.5, 0>, <0.8, 0.5>, <0.4, 1>, <0.5, 1.5>, <0, 2>
pigment { rgb 1 }
}
prism {
linear_sweep
linear_spline
0, 1, 5,
<0, 0>, <1, 0>, <1, 1>, <0, 1>, <0, 0>
pigment { rgb <1, 0.5, 0> }
}
prism {
conic_sweep
linear_spline
0, 1, 4,
<-1, -1>, <1, -1>, <0, 1>, <-1, -1>
open
translate x*3
}
sor {
5,
<0, 0>, <1, 0>, <0.5, 1>, <1, 2>, <0, 3>
open
pigment { rgb <0, 1, 0> }
translate -x*3
}text
text { ttf "file.ttf" | internal n
[cmap { platform, encoding [charset c] }]
"string", thickness, <offset> [modifiers] }| Item | Default | Meaning |
|---|---|---|
ttf "file" | one of the two font forms is required | the name of a TrueType font file (.ttf or .ttc); it is searched in the current directory and the library paths. A font that was opened for another text is reused |
internal n | a font built into the program: 1 is timrom.ttf, 2 is cyrvetic.ttf, 3 is crystal.ttf; any other number is povlogo.ttf | |
cmap { platform, encoding } | any character map | picks one character map of the font by platform and encoding number (the two numbers are packed into one value). It makes the parser warn that the extension is experimental. The block may end with charset c |
charset c | UCS-4 when cmap is given | the character set of the string: 1200 (UCS-2), 1251 (Windows-1251), 1252 (Windows-1252), 10000 (Mac OS Roman), 12000 (UCS-4), 28591 (Latin-1) or -1 (legacy symbol fonts); another number is an error |
"string" | required | the text, any string expression |
thickness | required | the depth of the extrusion along +z |
<offset> | required | extra space added between the characters; normally 0, and 0.1*x adds a tenth of a unit |
The text is built as a union of the extruded letters. The origin is at the lower left front corner of the first letter; the text runs along +x, the baseline is the x axis, descenders go below it, the front faces lie in the x-y plane and the extrusion goes towards +z. Letters are about 0.5 to 0.75 units tall. The spacing and kerning come from the font. Only printable characters work: line feeds and tabs are not supported. After the shapes are made the parser turns the whole text by 0.001 degrees on each axis, to avoid cracks in the glyphs that lie exactly along an axis. In a scene that declares a version before 3.8 the parser gives a possible-error message that the text may not look as expected, because the character handling changed in 3.8. sturm is not accepted.
text { ttf "timrom.ttf" "POV-Ray" 1, 0.1*x pigment { rgb 1 } }
text {
internal 2
concat("Page ", str(3, 0, 0)) 0.5, <0, 0, 0>
pigment { rgb 1 }
translate y*-1
}Polygon, triangle, smooth_triangle and bicubic_patch
These have no inside. In CSG an intersection gives a warning when one is used (Patch objects not allowed in intersection.). See Constructive solid geometry.
polygon
polygon { n, <p1>, <p2>, ... <pn> [modifiers] }| Item | Meaning |
|---|---|
n | the number of points; at least 3 |
| points | 3D vectors that lie in one plane. A 2D vector <x, y> is read as a point with z equal to 0 |
A flat shape with any number of straight sides. Repeating the first point of a sub-polygon closes it and the next point starts a new one, so one polygon can hold several outlines. A point is inside if a line from it crosses an odd number of edges, so where an even number of outlines overlap there is a hole. If the last outline is not closed the parser warns (Polygon not closed. Closing it.) and closes it. Points that differ by less than a tiny tolerance count as equal. If the points are not coplanar the object is marked degenerate and is silently ignored: the source has the warning only as a comment, so the manual's "an error occurs" does not happen.
triangle
triangle { <corner1>, <corner2>, <corner3> [modifiers] }One flat triangle. A triangle of zero area gives the warning Degenerate triangle. Please remove.
smooth_triangle
smooth_triangle { <corner1>, <normal1>, <corner2>, <normal2>, <corner3>, <normal3> [modifiers] }A triangle whose normal is interpolated between the three given normals, so it looks curved. The parser makes each normal a unit vector. If a normal has no length, or the triangle has no area, the warning Degenerate triangle. Please remove. is given. To join smoothly, triangles that share a corner need the same normal there.
bicubic_patch
bicubic_patch { type t [flatness f] [u_steps u] [v_steps v] [accuracy a]
[uv_vectors <u1,v1>, <u2,v2>, <u3,v3>, <u4,v4>]
<p1>, <p2>, ... <p16> [modifiers] }| Keyword | Value | Default | Meaning |
|---|---|---|---|
type | 0 or 1 | none: required | 0 keeps only the control points and subdivides while rendering (little memory, slower). 1 builds a tree of sub-patches while parsing (faster, more memory). A value above 1 gives a warning and is treated as 1; a negative value, or no type, is the error Undefined bicubic patch type. |
flatness | float | 0 | a piece of the patch that is flatter than this is not split further; 0 always splits down to the step limit |
u_steps | integer | 0 | the depth of the subdivision in u; up to 2u_steps pieces along u |
v_steps | integer | 0 | the same for v |
accuracy | float | 0.01 | read by the parser and stored; the intersection code does not use it |
uv_vectors | four 2D vectors | <0,0>, <1,0>, <1,1>, <0,1> | the texture coordinates of the four corners, for uv_mapping. After this keyword the parser stops reading keywords, so write it last, directly before the control points |
| 16 points | 3D vectors | required | the Bezier control points in 4 rows of 4. The patch passes through points 1, 4, 13 and 16; the other twelve pull it into shape. The patch lies inside the convex hull of the points |
The four words type, flatness, u_steps and v_steps may come in any order. An old form, where the first thing is a plain number, is still read: the numbers are the type, the flatness (read only if the type is 2 or 3, otherwise 0.1) and the two step counts, with a warning that keywords should be used. The normals are interpolated, so a patch looks smooth. A patch cannot be inverted (inverse warns Cannot invert a patch object.).
polygon {
5,
<0, 0, 0>, <1, 0, 0>, <1, 1, 0>, <0, 1, 0>, <0, 0, 0>
pigment { rgb 1 }
}
triangle { <0, 0, 0>, <1, 0, 0>, <0, 1, 0> pigment { rgb <1, 0, 0> } }
smooth_triangle {
<0, 0, 0>, <-1, 0, -1>,
<1, 0, 0>, <1, 0, -1>,
<0, 1, 0>, <0, 1, -1>
pigment { rgb <0, 0, 1> }
}
bicubic_patch {
type 1
flatness 0.01
u_steps 4
v_steps 4
<0, 0, 2>, <1, 0, 0>, <2, 0, 0>, <3, 0, -2>,
<0, 1, 0>, <1, 1, 0>, <2, 1, 0>, <3, 1, 0>,
<0, 2, 0>, <1, 2, 0>, <2, 2, 0>, <3, 2, 0>,
<0, 3, 2>, <1, 3, 0>, <2, 3, 0>, <3, 3, -2>
pigment { rgb 1 }
}blob
blob { [threshold t]
sphere { <centre>, radius, [strength] s [component modifiers] }
cylinder { <end1>, <end2>, radius, [strength] s [component modifiers] }
component s, radius, <centre>
[sturm] [hierarchy] [modifiers] }| Item | Default | Meaning |
|---|---|---|
threshold | 1.0 | the field strength that makes the surface. It should be positive. A component whose strength is below the threshold cannot make a surface alone. A larger threshold pulls the surface towards the component centres |
sphere | a spherical component; its field is s at the centre and falls to 0 at radius | |
cylinder | a component along a line with hemispherical ends: the field is s on the axis and falls to 0 at radius from it. If the two ends are less than a tiny distance apart the parser stops with Degenerate cylindrical component in blob. | |
strength | (the word is optional) | the number after the radius, the field at the centre. It may be negative: the component then repels the others and dents the surface. Zero adds nothing |
component | the old way to write a spherical component, with the strength first. It cannot have its own texture or transformations | |
| component modifiers | in a sphere or cylinder block, after the strength: translate, rotate, scale, transform, matrix, texture, pigment, normal, finish. Scaling a sphere unevenly makes an ellipsoid component. A component cannot have its own interior | |
sturm | off | the more accurate root solver |
hierarchy | on | a bounding sphere tree over the components; hierarchy off turns it off |
The field of the whole blob is the sum of the fields of its components; the surface is where the sum equals the threshold, and points where it is larger are inside. Components and the threshold can come in any order. The textures of the components are collected before the blob is built, so a blob can have a different texture on each component.
sphere_sweep
sphere_sweep { linear_spline | cubic_spline | b_spline
n, <c1>, r1, <c2>, r2, ... <cn>, rn
[tolerance t] [modifiers] }| Item | Default | Meaning |
|---|---|---|
| spline type | required (the parser stops with Invalid type of interpolation. without it) | linear_spline joins the spheres with straight tubes; cubic_spline is a Catmull-Rom spline that passes through the spheres (the first and last are controls); b_spline is a cubic B-spline that approximates them |
n | required | the number of spheres: at least 2 for linear, at least 4 for the others |
| spheres | required | n pairs of a centre vector and a radius |
tolerance | 1e-6 | the smallest distance a ray must travel before it may hit the object; raise it to 1e-4 or more if dark spots appear from self-shadowing |
The surface is the envelope of a ball that moves along the spline while its radius changes: the space the moving sphere sweeps through. The manual warns against merge with sphere sweeps, as the merged surface can leave a small gap.
julia_fractal
julia_fractal { <x, y, z, w>
[quaternion | hypercomplex] [function]
[max_iteration n] [precision p] [slice <a, b, c, d>, distance]
[modifiers] }| Keyword | Value | Default | Meaning |
|---|---|---|---|
| (first item) | 4D vector | required | the Julia parameter p in the iteration h(n+1) = f(h(n)) + p |
quaternion | flag | this one | the 4D algebra of quaternions. It supports only the functions sqr and cube; another function is an error (Illegal function: quaternion only supports sqr and cube) |
hypercomplex | flag | off | the hypercomplex algebra, which supports all the functions below |
| function | one word | sqr | the function f: sqr, cube, exp, reciprocal, sin, asin, sinh, asinh, cos, acos, cosh, acosh, tan, atan, tanh, atanh, ln or pwr(x, y) (h raised to the complex power x + yi). The last one given wins |
max_iteration | number | 20 | the number of iterations before a point is taken as inside; the number is rounded down and a value of 0 or less becomes 1. A low value fuses the dust into a solid |
precision | number | 20 | the accuracy of the surface test. The parser keeps its reciprocal. A value below 1 is changed to 1 |
slice | 4D vector, comma, number | <0,0,0,1>, 0 | the 3D slice of the 4D shape: the plane perpendicular to the vector at the given distance from the origin. The parser makes the vector a unit vector. A zero vector, or a vector with a zero fourth component, is an error (Slice vector is zero., Slice t component is zero.) |
A Julia fractal is a 3D slice of a 4D set. A 4D point is inside if the sequence of iterations does not leave a hypersphere of radius 4 within max_iteration steps. A distance estimate speeds up the quaternion case. The parser has no keywords named type, algebra or distance: the algebra is chosen by the two flag words and the distance is the number after slice.
blob {
threshold 0.6
sphere { <-0.5, 0, 0>, 1, 1 }
sphere { <0.5, 0, 0>, 1, strength 1 }
cylinder { <0, -1, 0>, <0, 1, 0>, 0.3, 0.8 }
sturm
pigment { rgb <1, 0.5, 0> }
}
sphere_sweep {
b_spline
4,
<-2, 0, 0>, 0.3,
<-1, 1, 0>, 0.2,
<1, -1, 0>, 0.4,
<2, 0, 0>, 0.3
tolerance 0.0001
pigment { rgb <0, 1, 0> }
}
julia_fractal {
<-0.083, 0.0, -0.83, -0.025>
quaternion
sqr
max_iteration 8
precision 15
slice <0, 0, 0, 1>, 0
pigment { rgb 1 }
}
julia_fractal {
<0.2, 0.3, -0.5, 0>
hypercomplex
pwr(2, 0)
max_iteration 6
precision 10
slice <0, 0, 0, 1>, 0.1
pigment { rgb 1 }
translate -x*3
}Notes
- The shapes that are not in this table because they have no finite size (
plane,poly,cubic,quartic,polynomial,quadric) and the ones that a function or an image defines (isosurface,parametric,height_field) are on Infinite and implicit objects. - The one place where this page differs from the manual: a polygon whose points are not coplanar is ignored without a message (see polygon).
Not described
Known, not yet covered
- Reference: the equations behind the shapes (the blob density, the superellipsoid equation, the iteration formulas of each julia function, the spline coefficients) are not repeated here; they are in the reference manual.
Unknown
- Reference: which of the two superellipsoid exponents belongs to which axis was not checked against an image; the page gives only what the parser stores.