|
Ray-tracing is known for the dramatic way it depicts reflection, refraction and lighting effects. 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 aren't really there.
Suppose you 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
vector. This is a vector which points away from the surface and is
perpendicular to it. By artificially modifying (or perturbing) this normal
vector you can simulate bumps. This is done by adding an optional
normal statement.
Note: that attaching a normal pattern does not really modify the surface. It only affects the way light reflects or refracts at the surface so that it looks bumpy.
The syntax is:
NORMAL:
normal { [NORMAL_IDENTIFIER] [NORMAL_TYPE] [NORMAL_MODIFIER...] }
NORMAL_TYPE:
PATTERN_TYPE Amount |
bump_map { BITMAP_TYPE "bitmap.ext" [BUMP_MAP_MODS...]}
NORMAL_MODIFIER:
PATTERN_MODIFIER | NORMAL_LIST | normal_map { NORMAL_MAP_BODY } |
slope_map{ SLOPE_MAP_BODY } | bump_size Amount |
no_bump_scale Bool | accuracy Float
Each of the items in a normal are optional but if they are present, they must be in the order shown. Any items after the NORMAL_IDENTIFIER modify or override settings given in the identifier. If no identifier is specified then the items modify the normal values in the current default texture. The PATTERN_TYPE may optionally be followed by a float value that controls the apparent depth of the bumps. Typical values range from 0.0 to 1.0 but any value may be used. Negative values invert the pattern. The default value if none is specified is 0.5.
There are four basic types of NORMAL_TYPEs. They are block pattern
normals, continuous pattern normals, specialized normals and bump maps. They
differ in the types of modifiers you may use with them. The pattern type is
optionally followed by one or more normal modifiers. In addition to general
pattern modifiers such as transformations, turbulence, and warp modifiers,
normals may also have a NORMAL_LIST, slope_map,
normal_map, and bump_size which are specific to normals.
See "Pattern Modifiers" for information on general modifiers. The
normal-specific modifiers are described in sub-sections which follow. Normal
modifiers of any kind apply only to the normal and not to other parts of the
texture. Modifiers must be specified last.
Originally POV-Ray had some patterns which were exclusively used for
pigments while others were exclusively used for normals. Since POV-Ray 3.0
you can use any pattern for either pigments or normals. For example it is now
valid to use ripples as a pigment or wood as a
normal type. The patterns bumps, dents,
ripples, waves, wrinkles, and
bump_map were once exclusively normal patterns which could not be used
as pigments. Because these six types use specialized normal modification
calculations they cannot have slope_map,
normal_map or wave shape modifiers. All other normal pattern types may
use them. Because block patterns checker, hexagon, object
and brick do not return a continuous series of values, they
cannot use these modifiers either. See "Patterns" for details about
specific patterns.
A normal statement is part of a texture
specification. However it can be tedious to use a texture
statement just to add bumps to an object. Therefore you may attach a normal
directly to an object without explicitly specifying that it as part of a
texture. For example instead of this:
object {My_Object texture { normal { bumps 0.5 } } }
you may shorten it to:
object { My_Object normal { bumps 0.5 } }
Doing so creates an entire texture
structure with default pigment and finish
statements just as if you had explicitly typed the full
texture {...} around it. Normal identifiers may be declared to make
scene files more readable and to parameterize scenes so that changing a
single declaration changes many values. An identifier is declared as
follows.
NORMAL_DECLARATION:
#declare IDENTIFIER = NORMAL |
#local IDENTIFIER = NORMAL
Where IDENTIFIER is the name of the identifier up to 40
characters long and NORMAL is any valid normal
statement. See "#declare vs. #local" for information on identifier
scope.
A slope_map is a normal pattern modifier which gives the user
a great deal of control over the exact shape of the bumpy features. Each of
the various pattern types available is in fact a mathematical function that
takes any x, y, z location and turns it into a number between 0.0 and 1.0
inclusive. That number is used to specify where the various high and low
spots are. The slope_map lets you further shape the contours. It
is best illustrated with a gradient normal pattern. Suppose you have...
plane{ z, 0
pigment{ White }
normal { gradient x }
}
This gives a ramp wave pattern that looks like small linear ramps that climb from the points at x=0 to x=1 and then abruptly drops to 0 again to repeat the ramp from x=1 to x=2. A slope map turns this simple linear ramp into almost any wave shape you want. The syntax is as follows...
SLOPE_MAP:
slope_map { SLOPE_MAP_BODY }
SLOPE_MAP_BODY:
SLOPE_MAP_IDENTIFIER | SLOPE_MAP_ENTRY...
SLOPE_MAP_ENTRY:
[ Value, <Height, Slope> ]
Note: the [] brackets are part of the actual
SLOPE_MAP_ENTRY. They are not notational symbols denoting optional
parts. The brackets surround each entry in the slope map.
There may be from 2 to 256 entries in the map.
Each Value is a float value between 0.0 and 1.0
inclusive and each <Height,
Slope> is a 2 component vector such as <0,1> where the
first value represents the apparent height of the wave and the second value
represents the slope of the wave at that point. The height should range
between 0.0 and 1.0 but any value could be used.
The slope value is the change in height per unit of distance. For example a slope of zero means flat, a slope of 1.0 means slope upwards at a 45 degree angle and a slope of -1 means slope down at 45 degrees. Theoretically a slope straight up would have infinite slope. In practice, slope values should be kept in the range -3.0 to +3.0. Keep in mind that this is only the visually apparent slope. A normal does not actually change the surface.
For example here is how to make the ramp slope up for the first half and back down on the second half creating a triangle wave with a sharp peak in the center.
normal {
gradient x // this is the PATTERN_TYPE
slope_map {
[0 <0, 1>] // start at bottom and slope up
[0.5 <1, 1>] // halfway through reach top still climbing
[0.5 <1,-1>] // abruptly slope down
[1 <0,-1>] // finish on down slope at bottom
}
}
The pattern function is evaluated and the result is a value from 0.0 to 1.0. The first entry says that at x=0 the apparent height is 0 and the slope is 1. At x=0.5 we are at height 1 and slope is still up at 1. The third entry also specifies that at x=0.5 (actually at some tiny fraction above 0.5) we have height 1 but slope -1 which is downwards. Finally at x=1 we are at height 0 again and still sloping down with slope -1.
Although this example connects the points using straight lines the shape is actually a cubic spline. This example creates a smooth sine wave.
normal {
gradient x // this is the PATTERN_TYPE
slope_map {
[0 <0.5, 1>] // start in middle and slope up
[0.25 <1.0, 0>] // flat slope at top of wave
[0.5 <0.5,-1>] // slope down at mid point
[0.75 <0.0, 0>] // flat slope at bottom
[1 <0.5, 1>] // finish in middle and slope up
}
}
This example starts at height 0.5 sloping up at slope 1. At a fourth of
the way through we are at the top of the curve at height 1 with slope 0 which
is flat. The space between these two is a gentle curve because the start and
end slopes are different. At half way we are at half height sloping down to
bottom out at 3/4ths. By the end we are climbing at slope 1 again to complete
the cycle. There are more examples in slopemap.pov in the
sample scenes.
A slope_map may be used with any pattern except
brick, checker, object, hexagon,
bumps, dents, ripples, waves,
wrinkles and bump_map.
You may declare and use slope map identifiers. For example:
#declare Fancy_Wave =
slope_map { // Now let's get fancy
[0.0 <0, 1>] // Do tiny triangle here
[0.2 <1, 1>] // down
[0.2 <1,-1>] // to
[0.4 <0,-1>] // here.
[0.4 <0, 0>] // Flat area
[0.5 <0, 0>] // through here.
[0.5 <1, 0>] // Square wave leading edge
[0.6 <1, 0>] // trailing edge
[0.6 <0, 0>] // Flat again
[0.7 <0, 0>] // through here.
[0.7 <0, 3>] // Start scallop
[0.8 <1, 0>] // flat on top
[0.9 <0,-3>] // finish here.
[0.9 <0, 0>] // Flat remaining through 1.0
}
object{ My_Object
pigment { White }
normal {
wood
slope_map { Fancy_Wave }
}
}
Surface normals that use patterns that were not designed for use with normals (anything other than bumps, dents, waves, ripples, and wrinkles) uses a slope_map whether you specify one or not. To create a perturbed normal from a pattern, POV-Ray samples the pattern at four points in a pyramid surrounding the desired point to determine the gradient of the pattern at the center of the pyramid. The distance that these points are from the center point determines the accuracy of the approximation. Using points too close together causes floating-point inaccuracies. However, using points too far apart can lead to artefacts as well as smoothing out features that should not be smooth.
Usually, points very close together are desired. POV-Ray currently uses a delta or accuracy distance of 0.02. Sometimes it is necessary to decrease this value to get better accuracy if you are viewing a close-up of the texture. Other times, it is nice to increase this value to smooth out sharp edges in the normal (for example, when using a 'solid' crackle pattern). For this reason, a new property, accuracy, has been added to normals. It only makes a difference if the normal uses a slope_map (either specified or implied).
You can specify the value of this accuracy (which is the distance between the sample points when determining the gradient of the pattern for slope_map) by adding accuracy <float> to your normal. For all patterns, the default is 0.02.
Most of the time you will apply single normal pattern to an entire surface
but you may also create a pattern or blend of normals using a
normal_map. The syntax for a normal_map is identical to a
pigment_map except you specify a normal in each
map entry. The syntax for normal_map is as follows:
NORMAL_MAP:
normal_map { NORMAL_MAP_BODY }
NORMAL_MAP_BODY:
NORMAL_MAP_IDENTIFIER | NORMAL_MAP_ENTRY...
NORMAL_MAP_ENTRY:
[ Value NORMAL_BODY ]
Where Value is a float value between 0.0 and 1.0
inclusive and each NORMAL_BODY is anything which can be inside a
normal{...} statement. The normal keyword and
{} braces need not be specified.
Note: that the [] brackets are part of the actual
NORMAL_MAP_ENTRY. They are not notational symbols denoting optional
parts. The brackets surround each entry in the normal map.
There may be from 2 to 256 entries in the map.
For example
normal {
gradient x //this is the PATTERN_TYPE
normal_map {
[0.3 bumps scale 2]
[0.3 dents]
[0.6 dents]
[0.9 marble turbulence 1]
}
}
When the gradient x function returns values from 0.0 to 0.3
then the scaled bumps normal is used. From 0.3 to 0.6 dents pattern is used.
From 0.6 up to 0.9 a blend of dents and a turbulent marble is used. From 0.9
on up only the turbulent marble is used.
Normal maps may be nested to any level of complexity you desire. The normals in a map may have slope maps or normal maps or any type of normal you want.
A normal map is also used with the average normal type. See
"Average" for details.
Entire normals in a normal list may also be used with the block patterns
such as checker, hexagon and brick.
For example...
normal {
checker
normal { gradient x scale .2 }
normal { gradient y scale .2 }
}
Note: in the case of block patterns the normal wrapping
is required around the normal information.
You may not use normal_map or individual normals with a
bump_map. See section "Texture Maps" for an alternative way
to do this.
You may declare and use normal map identifiers but the only way to declare a normal block pattern list is to declare a normal identifier for the entire normal.
When all else fails and none of the above normal pattern types meets your
needs you can use a bump_map to wrap a 2-D bit-mapped bump
pattern around your 3-D objects.
Instead of placing the color of the image on the shape like an
image_map a bump_map perturbs the surface normal based on
the color of the image at that point. The result looks like the image has
been embossed into the surface. By default, a bump map uses the brightness of
the actual color of the pixel. Colors are converted to gray scale internally
before calculating height. Black is a low spot, white is a high spot. The
image's index values may be used instead (see section "Use_Index
and Use_Color" below).
The syntax for a bump_map is:
BUMP_MAP:
normal
{
bump_map
{
BITMAP_TYPE "bitmap.ext"
[BUMP_MAP_MODS...]
}
[NORMAL_MODFIERS...]
}
BITMAP_TYPE:
gif | tga | iff | ppm | pgm | png | jpeg | tiff | sys
BUMP_MAP_MOD:
map_type Type | once | interpolate Type | use_color |
use_colour | bump_size Value
After the required BITMAP_TYPE keyword is a string expression containing the name of a bitmapped bump file of the specified type. Several optional modifiers may follow the file specification. The modifiers are described below.
Note: earlier versions of POV-Ray allowed some modifiers before the BITMAP_TYPE but that syntax is being phased out in favor of the syntax described here.
Note: sys format is a
system-specific format such as BMP for Windows or Pict for Macintosh.
Filenames specified in the bump_map statements will be searched
for in the home (current) directory first and, if not found, will then be
searched for in directories specified by any +L or
Library_Path options active. This would facilitate keeping all your
bump maps files in a separate subdirectory and giving a
Library_Path option to specify where your library of bump maps are.
See "Library Paths" for details.
By default, the bump pattern is mapped onto the x-y-plane. The bump pattern is projected onto the object as though there were a slide projector somewhere in the -z-direction. The pattern exactly fills the square area from (x,y) coordinates (0,0) to (1,1) regardless of the pattern's original size in pixels. If you would like to change this default you may translate, rotate or scale the pigment or texture to map it onto the object's surface as desired. If you would like to change this default orientation you may translate, rotate or scale the pigment or texture to map it onto the object's surface as desired.
The file name is optionally followed by one or more
BITMAP_MODIFIERS. The bump_size, use_color
and use_index modifiers are specific to bump maps and are
discussed in the following sections. See section "Bitmap Modifiers"
for the generic bitmap modifiers map_type, once and
interpolate described in "Bitmap Modifiers"
The relative bump size can be scaled using the bump_size
modifier. The bump size number can be any number other than 0 but typical
values are from about 0.1 to as high as 4.0 or 5.0.
normal {
bump_map {
gif "stuff.gif"
bump_size 5.0
}
}
Originally bump_size could only be used inside a bump map but
it can now be used with any normal. Typically it is used to override a
previously defined size. For example:
normal {
My_Normal //this is a previously defined normal identifier
bump_size 2.0
}
Usually the bump map converts the color of the pixel in the map to a gray
scale intensity value in the range 0.0 to 1.0 and calculates the bumps based
on that value. If you specify use_index, the bump map uses the
color's palette number to compute as the height of the bump at that
point. So, color number 0 would be low and color number 255 would be high (if
the image has 256 palette entries). The actual color of the pixels
doesn't matter when using the index. This option is only available on
palette based formats. The use_color keyword may be specified to
explicitly note that the color methods should be used instead. The alternate
spelling use_colour is also valid. These modifiers may only be
used inside the bump_map statement.
When scaling a normal, or when scaling an object after a normal
is applied to it, the depth of the normal is affected by the scaling. This is
not always wanted. If you want to turn off bump scaling for a texture or normal,
you can do this by adding the keyword no_bump_scale to the texture's
or normal's modifiers. This modifier will get passed on to all textures or normals
contained in that texture or normal. Think of this like the way no_shadow gets
passed on to objects contained in a CSG.
It is also important to note that if you add no_bump_scale to a normal or
texture that is contained within another pattern (such as within a texture_map
or normal_map), then the only scaling that will be ignored is the scaling of that
texture or normal. Scaling of the parent texture or normal or of the object will
affect the depth of the bumps, unless no_bump_scale is specified at the top-level
of the texture (or normal, if the normal is not wrapped in a texture).
|