### 2.2.5 Simple Texture Options

The pictures rendered so far where somewhat boring regarding the appearance of the objects. Let's add some fancy features to the texture.

#### 2.2.5.1 Surface Finishes

One of the main features of a ray-tracer is its ability to do interesting things with surface finishes such as highlights and reflection. Let's add a nice little Phong highlight (shiny spot) to a sphere. To do this we need to add a `finish` keyword followed by a parameter. We change the definition of the sphere to this:

      sphere {
        <0, 1, 2>, 2
        texture {
          pigment { color Yellow } //Yellow is pre-defined in COLORS.INC
          finish { phong 1 }
        }
      }

We render the scene. The `phong` keyword adds a highlight the same color of the light shining on the object. It adds a lot of credibility to the picture and makes the object look smooth and shiny. Lower values of phong will make the highlight less bright (values should be between 0 and 1).

#### 2.2.5.2 Adding Bumpiness

The highlight we have added illustrates how much of our perception depends on the reflective properties of an object. Ray-tracing can exploit this by playing tricks on our perception to make us see complex details that are not really there.

Suppose we wanted a very bumpy surface on the object. It would be very difficult to mathematically model lots of bumps. We can however simulate the way bumps look by altering the way light reflects off of the surface. Reflection calculations depend on a vector called a surface normal. This is a vector which points away from the surface and is perpendicular to it. By artificially modifying (or perturbing) this normal vector we can simulate bumps. We change the scene to read as follows and render it:

      sphere {
        <0, 1, 2>, 2
        texture {
          pigment { color Yellow }
          normal { bumps 0.4 scale 0.2 }
          finish { phong 1 }
        }
      }

This tells POV-Ray to use the `bumps` pattern to modify the surface normal. The value 0.4 controls the apparent depth of the bumps. Usually the bumps are about 1 unit wide which does not work very well with a sphere of radius 2. The scale makes the bumps 1/5th as wide but does not affect their depth.

#### 2.2.5.3 Creating Color Patterns

We can do more than assigning a solid color to an object. We can create complex patterns in the pigment block like in these examples:

      sphere {
        <0, 1, 2>, 2
        texture {
          pigment {
            wood
            color_map {
              [0.0 color DarkTan]
              [0.9 color DarkBrown]
              [1.0 color VeryDarkBrown]
            }
            turbulence 0.05
            scale <0.2, 0.3, 1>
          }
          finish { phong 1 }
        }
      }

      sphere {
        <0, 1, 2>, 2
        texture {
          pigment {
            wood
            color_map {
              [0.0 color Red]
              [0.5 color Red]
              [0.5 color Blue]
              [1.0 color Blue]
            }
            scale <0.2, 0.3, 1>
          }
          finish { phong 1 }
        }
      }

The keyword `wood` specifies a pigment pattern of concentric rings like rings in wood. For every position in POV-space, a pattern returns a float value in the range from zero to one. Values outside the zero to one range are ignored. The `color_map` specifies what color vector is assigned to that float value. In the first example the color of the wood blends from `DarkTan` to `DarkBrown` over the first 90% of the vein and from `DarkBrown` to `VeryDarkBrown` over the remaining 10%. In the second example the colors do not blend from one to an other, but change abrupt. The `turbulence` keyword slightly stirs up the pattern so the veins are not perfect circles and the `scale` keyword adjusts the size of the pattern.

Most patterns are set up by default to give us one feature across a sphere of radius 1.0. A feature is very roughly defined as a color transition. For example, a wood texture would have one band on a sphere of radius 1.0. In this example we scale the pattern using the `scale` keyword followed by a vector. In this case we scaled 0.2 in the x direction, 0.3 in the y direction and the z direction is scaled by 1, which leaves it unchanged. Scale values larger than one will stretch an element. Scale values smaller than one will squish an element. A scale value of one will leave an element unchanged.

#### 2.2.5.4 Pre-defined Textures

POV-Ray has some very sophisticated textures pre-defined in the standard include files `glass.inc`, `metals.inc`, `stones.inc` and `woods.inc`. Some are entire textures with pigment, normal and/or finish parameters already defined. Some are just pigments or just finishes.

We change the definition of our sphere to the following and then re-render it:

      sphere {
        <0, 1, 2>, 2
        texture {
          pigment {
            DMFWood4       // pre-defined in textures.inc
            scale 4        // scale by the same amount in all
                           // directions
          }
          finish { Shiny } // pre-defined in finish.inc
        }
      }

The pigment identifier `DMFWood4` has already been scaled down quite small when it was defined. For this example we want to scale the pattern larger. Because we want to scale it uniformly we can put a single value after the scale keyword rather than a vector of x, y, z scale factors.

We look through the file `textures.inc` to see what pigments and finishes are defined and try them out. We just insert the name of the new pigment where `DMFWood4` is now or try a different finish in place of `Shiny` and re-render our file.

Here is an example of using a complete texture identifier rather than just the pieces.

      sphere {
        <0, 1, 2>, 2
        texture { PinkAlabaster }
      }

More about "wood"

- 3.5.11.36 Wood in 3.5.11 Patterns
- 3.7.17.3 Woods in 3.7.17 textures.inc

More about "turbulence"

- 3.5.12 Pattern Modifiers in 3.5 Textures
- 3.5.12.5 Turbulence in 3.5.12 Pattern Modifiers
- 3.2.1.4.5 Functions in 3.2.1.4 Vector Expressions

More about "scale"

- 3.8.5 Transformations in 3.8 Quick Reference
- 2.2.7.1.2 Scale in 2.2.7.1 Transformations