# Reference:Slope Map

(diff) ← Older revision | Latest revision (diff) | Newer revision → (diff)
Jump to navigation Jump to search

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. For example:

```plane{ z, 0
pigment{ White }
normal { gradient x }
}
```

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.

In previous versions there had to be from 2 to 256 entries in the map. A Change in version 3.8 has removed the upper restriction.

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 }
}
}
```

## Normals, Accuracy

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.

For more on `slope_map` see the Slope Map Tutorial