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, POVRay 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 floatingpoint
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. POVRay 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 closeup 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.
