/* 2.3.4.1  Pigments
Every surface must have a color. In POV-Ray this color is called a pigment.
It does not have to be a single color. It can be a color pattern, a color
 list or even an image map. Pigments can also be layered one on top of
  the next so long as the uppermost layers are at least partially
   transparent so the ones beneath can show through. Let's play
   around with some of these kinds of pigments.

We create a file called texdemo.pov and edit it as follows: */

#include "colors.inc"
  camera {
    location <1, 1, -15>
    look_at 0
    angle 36
    rotate <45,0,0>
  }
  light_source { <1000, 1000, -1000> White * 1.5 }

  /*
  plane {
    y, -1.5
    pigment { checker Green, White }
  }   */

  sphere {
    <-3,0,-3>, 1
    pigment { Red }
  }

/*Giving this file a quick test render at 200x150 -A we see that it is a
simple red sphere against a green and white checkered plane. We will
be using the sphere for our textures.

2.3.4.1.1  Using Color List Pigments
Before we begin we should note that we have already made one kind
of pigment, the color list pigment. In the previous example we have
used a checkered pattern on our plane. There are three other kinds
of color list pigments, brick, hexagon and the object pattern.
Let's quickly try each of these. First, we change the plane's
pigment as follows:   */

  #declare p_hex = pigment { hexagon Green, White, Yellow }

/*Rendering this we see a three-color hexagonal pattern.
Note that this pattern requires three colors. Now we change the pigment to...*/

  #declare p_brick = pigment { brick Gray75, Red rotate -90*x scale .25 }

 /*Looking at the resulting image we see that the plane now
has a brick pattern. We note that we had to rotate the pattern
to make it appear correctly on the flat plane. This pattern
normally is meant to be used on vertical surfaces. We also
had to scale the pattern down a bit so we could see it more
easily. We can play around with these color list pigments,
change the colors, etc. until we get a floor that we like.

 2.3.4.1.2  Using Pigment and Patterns
 Let's begin texturing our sphere by using a pattern and a color map
consisting of three colors. We replace the pigment block with the following. */

#declare p_grad = pigment {
    gradient x
    color_map {
      [0.00 color Red]
      [0.33 color Blue]
      [0.66 color Yellow]
      [1.00 color Red]
    }
  }


/* Rendering this we see that the gradient pattern gives us an interesting
 pattern of vertical stripes. We change the gradient direction to y.
 The stripes are horizontal now. We change the gradient direction to z.
 The stripes are now more like concentric rings. This is because the
 gradient direction is directly away from the camera. We change the
 direction back to x and add the following to the pigment block.   */

#declare p_grad2 = pigment {
    gradient x
    color_map {
      [0.00 color Red]
      [0.33 color Blue]
      [0.66 color Yellow]
      [1.00 color Red]
    }
    rotate -45*z          // <- add this line
  }

/*The vertical bars are now slanted at a 45 degree angle. All patterns
can be rotated, scaled and translated in this manner. Let's now try
some different types of patterns. One at a time, we substitute the
following keywords for gradient x and render to see the result:
bozo, marble, agate, granite, leopard, spotted and wood
(if we like we can test all patterns listed in section "Patterns").   */

/* Rendering these we see that each results in a slightly different
pattern. But to get really good results each type of pattern
requires the use of some pattern modifiers.

2.3.4.1.3  Using Pattern Modifiers
Let's take a look at some pattern modifiers. First, we change
the pattern type to bozo. Then we add the following change.   */

#declare p_bozofreq = pigment {
    bozo
    frequency 3            // <- add this line
    color_map {
      [0.00 color Red]
      [0.33 color Blue]
      [0.66 color Yellow]
      [1.00 color Red]
    }
    rotate -45*z
  }

 /*The frequency modifier determines the number of times the color map
 repeats itself per unit of size. This change makes the bozo pattern we
 saw earlier have many more bands in it. Now we change the pattern type
 to marble. When we rendered this earlier, we saw a banded pattern similar
 to gradient y that really did not look much like marble at all. This is
 because marble really is a kind of gradient and it needs another pattern
 modifier to look like marble. This modifier is called turbulence. We
 change the line frequency 3 to turbulence 1 and render again. That's better!
 Now let's put frequency 3 back in right after the turbulence and take
 another look. Even more interesting!                                 */

/* But wait, it gets better! Turbulence itself has some modifiers of its own.
 We can adjust the turbulence several ways. First, the float that follows
 the turbulence keyword can be any value with higher values giving us
 more turbulence. Second, we can use the keywords omega, lambda and
 octaves to change the turbulence parameters.                       */

// Let's try this now:

#declare p_marble =  pigment {
    marble
    turbulence 0.5
    lambda 1.5
    omega 0.8
    octaves 5
    frequency 3
    color_map {
      [0.00 color Red]
      [0.33 color Blue]
      [0.66 color Yellow]
      [1.00 color Red]
    }
    rotate 45*z
  }

/* Rendering this we see that the turbulence has changed and the pattern
looks different. We play around with the numerical values of turbulence,
lambda, omega and octaves to see what they do.

2.3.4.1.4  Using Transparent Pigments and Layered Textures
Pigments are described by numerical values that give the rgb value of
the color to be used (like color rgb<1,0,0> giving us a red color).
But this syntax will give us more than just the rgb values. We can
specify filtering transparency by changing it as follows: color rgbf<1,0,0,1>.
The f stands for filter, POV-Ray's word for filtered transparency.
A value of one means that the color is completely transparent, but
still filters the light according to what the pigment is. In this case,
the color will be a transparent red, like red cellophane.

There is another kind of transparency in POV-Ray. It is called transmittance
or non-filtering transparency (the keyword is transmit; see also rgbt).
It is different from filter in that it does not filter the light
according to the pigment color. It instead allows all the light
to pass through unchanged. It can be specified like this: rgbt <1,0,0,1>.

Let's use some transparent pigments to create another kind of texture,
the layered texture. Returning to our previous example, declare the
following texture.                                                  */

#declare LandArea = texture {
      pigment {
        agate
        turbulence 1
        lambda 1.5
        omega .8
        octaves 8
        color_map {
          [0.00 color rgb <.5, .25, .15>]
          [0.33 color rgb <.1, .5, .4>]
          [0.86 color rgb <.6, .3, .1>]
          [1.00 color rgb <.5, .25, .15>]
        }
      }
    }

/* This texture will be the land area. Now let's make the oceans
by declaring the following. */

#declare OceanArea = texture {
      pigment {
        bozo
        turbulence .5
        lambda 2
        color_map {
          [0.00, 0.33 color rgb <0, 0, 1>
                      color rgb <0, 0, 1>]
          [0.33, 0.66 color rgbf <1, 1, 1, 1>
                      color rgbf <1, 1, 1, 1>]
          [0.66, 1.00 color rgb <0, 0, 1>
                      color rgb <0, 0, 1>]
        }
      }
    }

/* Note: how the ocean is the opaque blue area and the land is
 the clear area which will allow the underlying texture to show through.

 Now, let's declare one more texture to simulate an atmosphere
 with swirling clouds.                                     */

#declare CloudArea = texture {
    pigment {
      agate
      turbulence 1
      lambda 2
      frequency 2
      color_map {
        [0.0 color rgbf <1, 1, 1, 1>]
        [0.5 color rgbf <1, 1, 1, .35>]
        [1.0 color rgbf <1, 1, 1, 1>]
      }
    }
  }

sphere {
    <0,0,3>, 1
    pigment { p_grad }
  }
 /*  Now apply all of these to our sphere.  */

sphere {
    <-3,0,0>, 1
    texture { LandArea }
    texture { OceanArea }
    texture { CloudArea }
}

/*We render this and have a pretty good rendition of a little planetoid.
 But it could be better. We do not particularly like the appearance
  of the clouds. There is a way they could be done that would be
  much more realistic.

2.3.4.1.5  Using Pigment Maps
Pigments may be blended together in the same way as the colors in
 a color map using the same pattern keywords and a pigment_map.
  Let's just give it a try.

We add the following declarations, making sure they appear before
 the other declarations in the file.                             */

  #declare Clouds1 = pigment {
      bozo
      turbulence 1
      color_map {
        [0.0 color White filter 1]
        [0.5 color White]
        [1.0 color White filter 1]
      }
    }
  #declare Clouds2 = pigment {
    agate
    turbulence 1
    color_map {
      [0.0 color White filter 1]
      [0.5 color White]
      [1.0 color White filter 1]
      }
    }
  #declare Clouds3 = pigment {
    marble
    turbulence 1
    color_map {
      [0.0 color White filter 1]
      [0.5 color White]
      [1.0 color White filter 1]
    }
  }
  #declare Clouds4 = pigment {
    granite
    turbulence 1
    color_map {
      [0.0 color White filter 1]
      [0.5 color White]
      [1.0 color White filter 1]
    }
  }

/*Now we use these declared pigments in our cloud layer on our planetoid.
 We replace the declared cloud layer with.  */

  #declare CloudArea = texture {
    pigment {
      gradient y
      pigment_map {
        [0.00 Clouds1]
        [0.25 Clouds2]
        [0.50 Clouds3]
        [0.75 Clouds4]
        [1.00 Clouds1]
      }
    }
  }

/*We render this and see a remarkable pattern that looks very much like
  weather patterns on the planet earth. They are separated into bands,
  simulating the different weather types found at different latitudes.

2.3.4.2  Normals
Objects in POV-Ray have very smooth surfaces. This is not very realistic
 so there are several ways to disturb the smoothness of an object by
  perturbing the surface normal. The surface normal is the vector
   that is perpendicular to the angle of the surface. By changing
    this normal the surface can be made to appear bumpy, wrinkled
     or any of the many patterns available. Let's try a couple of them.

2.3.4.2.1  Using Basic Normal Modifiers
We comment out the planetoid sphere for now and, at the bottom of
 the file, create a new sphere with a simple, single color texture. */

sphere {
    <3,0,3>, 1
    pigment { Gray75 }
    normal { bumps 1 scale .2 }
  }

/*Here we have added a normal block in addition to the pigment block
 (note that these do not have to be included in a texture block
 unless they need to be transformed together or need to be part
 of a layered texture). We render this to see what it looks like.
 Now, one at a time, we substitute for the keyword bumps the following
 keywords: dents, wrinkles, ripples and waves (we can also use any of
 the patterns listed in "Patterns"). We render each to see what they
 look like. We play around with the float value that follows the keyword.
 We also experiment with the scale value.

For added interest, we change the plane texture to a single color with
a normal as follows.                                      */

  plane {
    y, -1.5
    pigment { color rgb <.65, .45, .35> }
    normal { dents .75 scale .25 }
  }

/*2.3.4.2.2  Blending Normals
Normals can be layered similar to pigments but the results can be
unexpected. Let's try that now by editing the sphere as follows.  */

  sphere {
    <-3,0,3>, 1
    pigment { Gray75 }
      normal { radial frequency 10 }
      normal { gradient y scale .2 }
  }

/*As we can see, the resulting pattern is neither a radial nor a
gradient. It is instead the result of first calculating a
radial pattern and then calculating a gradient pattern.
The results are simply additive. This can be difficult to
control so POV-Ray gives the user other ways to blend normals.

One way is to use normal maps. A normal map works the same way
as the pigment map we used earlier. Let's change our sphere texture
 as follows.
                                                                   */
  sphere {
    <3,0,-3>, 1
    pigment { Gray75 }
    normal {
      gradient y
      frequency 3
      turbulence .5
      normal_map {
        [0.00 granite]
        [0.25 spotted turbulence .35]
        [0.50 marble turbulence .5]
        [0.75 bozo turbulence .25]
        [1.00 granite]
      }
    }
  }

/*Rendering this we see that the sphere now has a very irregular
  bumpy surface. The gradient pattern type separates the normals
  into bands but they are turbulated, giving the surface a chaotic
  appearance. But this gives us an idea.

Suppose we use the same pattern for a normal map that we used to
create the oceans on our planetoid and applied it to the land areas.
Does it follow that if we use the same pattern and modifiers on a
sphere the same size that the shape of the pattern would be the same?
Would not that make the land areas bumpy while leaving the oceans
smooth? Let's try it. First, let's render the two spheres side-by-side
so we can see if the pattern is indeed the same. We un-comment the
planetoid sphere and make the following changes.                   */

  sphere {
    <3,0,0>, 1
    texture { LandArea }
    texture { OceanArea }
    //texture { CloudArea }  // <-comment this out
    //translate -x             // <- add this transformation
  }

   /* Now we change the gray sphere as follows. */

  sphere {
    <0,0,-3>, 1
    pigment { Gray75 }
    normal {
      bozo
      turbulence .5
      lambda 2
      normal_map {
        [0.4 dents .15 scale .01]
        [0.6 agate turbulence 1]
        [1.0 dents .15 scale .01]
      }
    }
    //translate x // <- add this transformation
  }

/*We render this to see if the pattern is the same.
 We see that indeed it is. So let's comment out the gray
 sphere and add the normal block it contains to the land
 area texture of our planetoid. We remove the transformations
 so that the planetoid is centered in the scene again.        */

  #declare LandArea = texture {
    pigment {
      agate
      turbulence 1
      lambda 1.5
      omega .8
      octaves 8
      color_map {
        [0.00 color rgb <.5, .25, .15>]
        [0.33 color rgb <.1, .5, .4>]
        [0.86 color rgb <.6, .3, .1>]
        [1.00 color rgb <.5, .25, .15>]
      }
    }
    normal {
      bozo
      turbulence .5
      lambda 2
      normal_map {
        [0.4 dents .15 scale .01]
        [0.6 agate turbulence 1]
        [1.0 dents .15 scale .01]
      }
    }
  }

  sphere {
    <0,0,0>, 1
                 texture {LandArea}
  }

Post a reply to this message