.POV File Format – Normals and finishes

The normal statement

normal {
  [normal identifier]
  [pattern type [amount]]
  [pattern modifiers]
  [normal_map { … } | slope_map { … }]
  [bump_size amount] [accuracy delta] [no_bump_scale]
}

The statement is used inside a texture, or directly in an object (sphere { … normal { bumps 0.5 } }, which builds a texture from the default pigment and finish). An identifier first, if present, supplies the starting normal; the other items modify it. An empty normal { } is the error “No normal type given.” After the pattern type an optional number gives the apparent depth of the bumps (bumps 0.4); a comma may separate it (gradient x, -0.5; the comma is needed when the number is negative). Negative values invert the bumps.

The items color_map, pigment_map, quick_color and texture_map are errors in a normal (“Only in pigment” and similar). A normal can be declared: #declare Name = normal { … }. Normals nested in a block pattern are written normal { … } each: normal { checker normal { bumps 0.2 } normal { granite 0.3 } }.

Patterns with their own normal formula

These six patterns do not use a height at all. They add a vector directly to the normal (the normal is then normalised). Because of that they cannot use slope_map, normal_map or wave types in a normal. As pigment or texture patterns they are ordinary patterns with a value.

All other patterns

Any other pattern is turned into a normal through its value used as a height. The parser samples the pattern at the four corners of a small pyramid around the point (the size is accuracy, 0.02), runs each value through the slope_map (or a built-in one if there is none), and adds the four weighted pyramid vectors to the normal. The weight is A × −5 × 0.02 / accuracy (two fudge factors in the source). The pattern value includes the wave type, frequency and phase, so sine_wave, scallop_wave and so on act as a built-in slope map. Block patterns (checker, brick, hexagon, square, triangular, cubic, object) and other jump patterns (cells, crackle with solid) have no slope, so they are poor normals: the edges appear. Their default accuracy is 0.02 as well.

slope_map

slope_map { [ value <height, slope> ] ... }   // or an identifier

The pattern value (0 to 1) is looked up in the map. height is the apparent height at that value (normally 0 to 1) and slope the apparent change of height per unit of distance: 0 is flat, 1 is a rise at 45 degrees, −1 a fall. Keep slopes in the range −3 to 3. Between two entries a cubic curve through the two heights and slopes is used, so smooth profiles are possible; two entries at the same value give a sudden change. Entries must be in ascending order; there is at least one entry and no upper limit in version 3.8. The parser refuses a slope map with average and with the block patterns (brick, checker, object, hexagon, square, triangular, cubic); the manual also excludes the patterns with their own formula.

normal_map

normal_map { [ value normal body ] ... }   // or an identifier

Each entry is what could stand inside normal { … }. Where two entries meet the two perturbed normals are mixed in proportion; otherwise one normal is used. With average the weights are optional numbers (default 1) and the perturbed normals are weighted, added and normalised. A normal_map cannot be used with bump_map (use a texture map instead). The general map grammar is on Patterns and maps.

bump_map

normal {
  bump_map {
    [bitmap_type] "file" | function w, h { body }
    [gamma g] [premultiplied bool]
    [map_type n] [once] [interpolate n]
    [bump_size amount] [use_colour | use_color | use_index]
    [repeat <u, v>] [offset <u, v>]
  }
  [normal modifiers]
}

A bump map wraps an image around the surface like an image map, but uses its brightness as a height: black is low, white is high, so the picture looks embossed. File types, gamma, premultiplied, map_type, once, interpolate, repeat and offset work as for image_map on Textures and pigments (the bump map does not check the values of map_type and interpolate). The image fills the square <0,0> to <1,1> of the x-y plane. The colour of each pixel is converted to grey. use_index uses the palette index as height instead (palette images only); use_colour selects the default again. With once the area outside the unit square stays flat. Images with an alpha channel are treated as if they had a black background. A bump map does no gamma adjustment of the file unless gamma is given. bump_size is the depth (typically 0.1 to 5; any value but 0).

sphere { 0, 1
  pigment { rgb 1 }
  normal { bumps 0.6 scale 0.2 }
}

sphere { <2.5, 0, 0>, 1
  pigment { rgb 1 }
  normal {
    gradient x, 0.5
    slope_map {
      [0   <0, 1>]
      [0.5 <1, 1>]
      [0.5 <1, -1>]
      [1   <0, -1>]
    }
    accuracy 0.01
    scale 0.25
  }
}

sphere { <-2.5, 0, 0>, 1
  pigment { rgb 1 }
  normal {
    gradient y
    normal_map {
      [0.0 bumps 0.3 scale 0.1]
      [0.5 ripples 0.4 frequency 6]
      [1.0 granite 0.2]
    }
    scale 0.5
  }
}

plane { y, -1.5
  pigment { rgb 1 }
  normal {
    bump_map {
      function 64, 64 { pattern { wood } }
      interpolate 2
      bump_size 2
    }
    no_bump_scale
    scale 2
  }
}

The finish statement

finish {
  [finish identifier]
  [items]
}

An identifier first, if present, is the starting point; the items modify it. Without an identifier the items modify the finish of the default texture. A finish is declared with #declare Name = finish { … }. Transformations are not allowed in a finish. Colour-valued items accept a single number, which is used for red, green and blue (the filter and transmit parts of a colour are not used).

reflection

reflection colour                       // old syntax: min = max = colour
reflection {
  min [, max]
  [fresnel bool] [falloff f] [exponent e] [metallic [m]]
}

Reflection adds rays and so render time. Reflected light can be tinted: reflection rgb <1, 0, 0> reflects only red.

irid

irid { amount [thickness t] [turbulence v] }

Bump patterns on the surface change the angles and so the colours of the film. The amount and the thickness are in microns since version 3.7.

subsurface

finish { subsurface { translucency colour anisotropy colour } }

Writing the block turns on the experimental flag, and the render prints a warning that experimental features are used. The effect works only when global_settings { subsurface { } } is present (it also takes samples diffuse, single and radiosity bool, see Global settings) and at render quality 9 or more. The object needs an interior { ior … }. The manual lists these limits: pigments with a zero colour component and a zero diffuse value can fail; unions of overlapping objects give unexpected results (use merge); meshes should be closed; parts that should not show seams must share one interior.

Finish presets in the include files

Include files declare finishes that can be used by name (finish { Shiny }), see Include files.

#declare Plastic = finish {
  ambient 0.05
  diffuse albedo 0.7
  phong albedo 0.3
  phong_size 60
}

#declare Metal = finish {
  ambient 0.1
  diffuse 0.4
  brilliance 3
  specular 0.7
  roughness 0.02
  metallic 0.8
  reflection { 0.1, 0.6 falloff 2 exponent 1.5 metallic 0.5 }
}

#declare Film = finish {
  diffuse 0.5
  irid { 0.25 thickness 0.5 turbulence 0.3 }
  crand 0.01
  emission rgb <0.02, 0.02, 0.05>
}

#declare Glassy = finish {
  ambient 0
  diffuse 0
  specular 0.8
  roughness 0.001
  reflection { 0.0, 1.0 fresnel on }
  conserve_energy
  use_alpha on
}

#declare Skin = finish {
  diffuse 0.6, 0.1
  subsurface { translucency rgb <0.5, 0.2, 0.1> anisotropy rgb 0.1 }
}

sphere { <-3, 0, 0>, 1 pigment { rgb <0.8, 0.2, 0.2> } finish { Plastic } }
sphere { <-1, 0, 0>, 1 pigment { rgb <0.9, 0.7, 0.3> } finish { Metal } }
sphere { <1, 0, 0>, 1 pigment { rgb <0.5, 0.5, 0.8> } finish { Film } }
sphere { <3, 0, 0>, 1 pigment { rgbf <1, 1, 1, 0.9> } finish { Glassy } interior { ior 1.5 } }
sphere { <0, 2, 0>, 0.7 pigment { rgb <0.9, 0.8, 0.7> } finish { Skin } interior { ior 1.4 } }
sphere { <0, -2, 0>, 0.7
  pigment { rgb 0.8 }
  finish { fresnel 0.5 specular albedo 1 roughness 0.01 }
  interior { ior 1.5 }
}

How the finish is used in lighting

For each layer of a texture, and for each light source that reaches the point, the renderer adds:

• the diffuse part: diffuse × adjust × |cos θ|^brilliance × pigment colour × light colour × attenuation, minus the random crand term, times (1 − f1)(1 − f2) when fresnel is set;
• the Phong highlight, if phong is not 0: phong × cos^phong_size, for a positive cosine, tinted with metallic and fresnel if set, in the colour of the light;
• the specular highlight, if specular is not 0, from the halfway vector, tinted the same way;
• the iridescence, which multiplies the result by 1 + irid × cos(phase / wavelength) for each colour component.

The ambient and emission are added once, not per light: emission + ambient × ambient_light (the ambient part only when radiosity is off or the scene is older than 3.7), multiplied by the pigment colour for the ambient part. The reflection ray is traced with the weight of the reflectivity, computed for the angle of incidence; the result is added to the colour.

Not described

Known, not yet covered

• Reference: the exact vector formulas of facets and of the bump_map height lookup are not written out (their parameters and effect are); the full subsurface algorithm in source/core/lighting/subsurface.cpp is not described.
• Reference: whether the normal-only bump patterns reject a slope_map or normal_map at parse time was not tested; the manual says they cannot use them.