File: s_116.html

package info (click to toggle)
povray 1%3A3.6.1-6
links: PTS
area: non-free
in suites: etch, etch-m68k
size: 31,052 kB
ctags: 20,305
sloc: ansic: 110,032; cpp: 86,573; sh: 13,595; pascal: 5,942; asm: 2,994; makefile: 1,747; ada: 1,637
file content (611 lines) | stat: -rw-r--r-- 25,454 bytes
parent folder | download | duplicates (2)

<!--  This file copyright Persistence of Vision Raytracer Pty. Ltd. 2003-2004  -->
<html> 
<head>
  
<!--  NOTE: In order to users to help find information about POV-Ray using  -->
 
<!--  web search engines, we ask you to *not* let them index documentation  -->
 
<!--  mirrors because effectively, when searching, users will get hundreds  -->
 
<!--  of results containing the same information! For this reason, the two  -->
 
<!--  meta tags below disable archiving and indexing of this page by all  -->
 
<!--  search engines that support these meta tags.  -->
 
 <meta content="noarchive" name="robots">
   
 <meta content="noindex" name="robots">
   
 <meta content="no-cache" http-equiv="Pragma">
   
 <meta content="0" http-equiv="expires">
   
<title>3.5.2 Normal</title>
 <link href="povray35.css" rel="stylesheet" type="text/css"> 
</head>
 <body> 
<table class="NavBar" width="100%">
  
 <tr>
   
  <td align="left" nowrap="" valign="middle" width="32">
    <a href="s_115.html"><img alt="previous" border="0" src="prev.png"></a> 
   
  </td>
   
  <td align="left" valign="middle" width="30%">
    <a href="s_115.html">3.5.1 Pigment</a> 
  </td>
   
  <td align="center" valign="middle">
    <strong class="NavBar">POV-Ray 3.6 for UNIX documentation</strong><br> <strong>3.5.2 
   Normal</strong> 
  </td>
   
  <td align="right" valign="middle" width="30%">
    <a href="s_117.html">3.5.3 Finish</a> 
  </td>
   
  <td align="right" nowrap="" valign="middle" width="32">
    <a href="s_117.html"><img alt="next" border="0" src="next.png"></a> 
   
  </td>
   
 </tr>
  
</table>
 
<h3><a name="s03_05_02">3.5.2 </a>Normal</h3>
<a name="s03_05_02_i1"><a name="normal"></a><a name="s03_05_02_i2"><a name="normal, keyword"></a><a name="s03_05_02_i3"><a name="s03_05_02_i4"><a name="bump_map, normal"></a><a name="s03_05_02_i5"><a name="s03_05_02_i6"><a name="normal_map, normal"></a><a name="s03_05_02_i7"><a name="s03_05_02_i8"><a name="slope_map, normal"></a><a name="s03_05_02_i9"><a name="s03_05_02_i10"><a name="bump_size, normal"></a><a name="s03_05_02_i11"><a name="s03_05_02_i12"><a name="no_bump_scale, normal"></a><a name="s03_05_02_i13"><a name="s03_05_02_i14"><a name="accuracy, normal"></a><a name="s03_05_02_i15">
<p>
  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 are not really there. 
</p>

<p>
  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 <em> surface normal</em> 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 <code> normal</code> statement. 
</p>

<p class="Note">
  <strong>Note:</strong> 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. 
</p>

<p>
  The syntax is: 
</p>

<pre>
NORMAL:
  normal { [NORMAL_IDENTIFIER] [NORMAL_TYPE] [NORMAL_MODIFIER...] }
NORMAL_TYPE:
  PATTERN_TYPE Amount |
  bump_map { BITMAP_TYPE &quot;bitmap.ext&quot; [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
</pre>

<p>
  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 <em>NORMAL_IDENTIFIER</em> 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 <em>PATTERN_TYPE</em> 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. 
</p>

<p>
  There are four basic types of <em>NORMAL_TYPE</em>s. 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 <em>NORMAL_LIST</em>, <code>slope_map</code>, <code> normal_map</code>, 
 and <code>bump_size</code> which are specific to normals. See &quot;<a href="#l143">Pattern Modifiers</a>&quot; 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. 
</p>

<p>
  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 <code>ripples</code> as a pigment or <code>wood</code> as a normal type. The patterns <code>bumps</code>, <code>dents</code>, 
 <code> ripples</code>, <code>waves</code>, <code> wrinkles</code>, and <code> bump_map</code> were once exclusively 
 normal patterns which could not be used as pigments. Because these six types use specialized normal modification 
 calculations they cannot have <code> slope_map</code>, <code> normal_map</code> or wave shape modifiers. All other 
 normal pattern types may use them. Because block patterns <code> checker</code>, <code>hexagon</code>, <code>object</code> 
 and <code> brick</code> do not return a continuous series of values, they cannot use these modifiers either. See &quot;<a href="s_125.html#s03_05_11">Patterns</a>&quot; 
 for details about specific patterns. 
</p>

<p>
  A <code> normal</code> statement is part of a <code> texture</code> specification. However it can be tedious to use 
 a <code> texture</code> 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: 
</p>

<pre>
  object  {My_Object texture { normal { bumps 0.5 } } }
</pre>

<p>
  you may shorten it to: 
</p>

<pre>
  object { My_Object normal { bumps 0.5 } }
</pre>

<p>
  Doing so creates an entire <code>texture</code> structure with default <code>pigment</code> and <code>finish</code> 
 statements just as if you had explicitly typed the full <code> texture {...}</code> 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. 
</p>

<pre>
NORMAL_DECLARATION:
    #declare IDENTIFIER = NORMAL |
    #local IDENTIFIER = NORMAL
</pre>

<p>
  Where <em>IDENTIFIER</em> is the name of the identifier up to 40 characters long and <em>NORMAL</em> is any valid <code>normal</code> 
 statement. See &quot;<a href="s_98.html#s03_02_02_02_02">#declare vs. #local</a>&quot; for information on identifier 
 scope. 
</p>

<h4><a name="s03_05_02_01">3.5.2.1 </a>Slope Maps</h4>
<a name="s03_05_02_01_i1"><a name="slope_map"></a>
<p>
  A <code>slope_map</code> 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 <code>slope_map</code> lets you further shape the contours. It is best 
 illustrated with a gradient normal pattern. Suppose you have... 
</p>

<pre>
  plane{ z, 0
    pigment{ White }
    normal { gradient x }
  }
</pre>

<p>
  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... 
</p>

<pre>
SLOPE_MAP:
    slope_map { SLOPE_MAP_BODY }
SLOPE_MAP_BODY:
    SLOPE_MAP_IDENTIFIER | SLOPE_MAP_ENTRY...
SLOPE_MAP_ENTRY:
    [ Value, &lt;Height, Slope&gt; ]
</pre>

<p class="Note">
  <strong>Note:</strong> the <code>[]</code> brackets are part of the actual <em> SLOPE_MAP_ENTRY</em>. 
 They are not notational symbols denoting optional parts. The brackets surround each entry in the slope map. 
</p>

<p>
  There may be from 2 to 256 entries in the map. 
</p>

<p>
  Each <em><code>Value</code></em> is a float value between 0.0 and 1.0 inclusive and each <em><code> &lt;Height</code></em>, 
 <em> <code> Slope&gt;</code></em> is a 2 component vector such as &lt;0,1&gt; 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. 
</p>

<p>
  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. 
</p>

<p>
  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. 
</p>

<pre>
  normal {
    gradient x       // this is the PATTERN_TYPE
    slope_map {
      [0   &lt;0, 1&gt;]   // start at bottom and slope up
      [0.5 &lt;1, 1&gt;]   // halfway through reach top still climbing
      [0.5 &lt;1,-1&gt;]   // abruptly slope down
      [1   &lt;0,-1&gt;]   // finish on down slope at bottom
    }
  }
</pre>

<p>
  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. 
</p>

<p>
  Although this example connects the points using straight lines the shape is actually a cubic spline. This example 
 creates a smooth sine wave. 
</p>

<pre>
  normal {
    gradient x          // this is the PATTERN_TYPE
    slope_map {
      [0    &lt;0.5, 1&gt;]   // start in middle and slope up
      [0.25 &lt;1.0, 0&gt;]   // flat slope at top of wave
      [0.5  &lt;0.5,-1&gt;]   // slope down at mid point
      [0.75 &lt;0.0, 0&gt;]   // flat slope at bottom
      [1    &lt;0.5, 1&gt;]   // finish in middle and slope up
    }
  }
</pre>

<p>
  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 <code> slopemap.pov</code> in the sample 
 scenes. 
</p>

<p>
  A <code>slope_map</code> may be used with any pattern except <code> brick</code>, <code>checker</code>, <code>object</code>, 
 <code>hexagon</code>, <code> bumps</code>, <code>dents</code>, <code> ripples</code>, <code>waves</code>, <code> 
 wrinkles</code> and <code> bump_map</code>. 
</p>

<p>
  You may declare and use slope map identifiers. For example: 
</p>

<pre>
  #declare Fancy_Wave =
    slope_map {       // Now let's get fancy
      [0.0  &lt;0, 1&gt;]   // Do tiny triangle here
      [0.2  &lt;1, 1&gt;]   //  down
      [0.2  &lt;1,-1&gt;]   //     to
      [0.4  &lt;0,-1&gt;]   //       here.
      [0.4  &lt;0, 0&gt;]   // Flat area
      [0.5  &lt;0, 0&gt;]   //   through here.
      [0.5  &lt;1, 0&gt;]   // Square wave leading edge
      [0.6  &lt;1, 0&gt;]   //   trailing edge
      [0.6  &lt;0, 0&gt;]   // Flat again
      [0.7  &lt;0, 0&gt;]   //   through here.
      [0.7  &lt;0, 3&gt;]   // Start scallop
      [0.8  &lt;1, 0&gt;]   //   flat on top
      [0.9  &lt;0,-3&gt;]   //     finish here.
      [0.9  &lt;0, 0&gt;]   // Flat remaining through 1.0
    }
  object{ My_Object
    pigment { White }
    normal {
      wood
      slope_map { Fancy_Wave }
    }
  }
</pre>

<h5><a name="s03_05_02_01_01">3.5.2.1.1 </a>Normals, Accuracy</h5>
<a name="s03_05_02_01_01_i1"><a name="accuracy, normals"></a>
<p>
  Surface normals that use patterns that were not designed for use with normals (anything other than bumps, dents, 
 waves, ripples, and wrinkles) uses a <code>slope_map</code> 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. 
</p>

<p>
  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, <code>accuracy</code>, has been added to normals. It only 
 makes a difference if the normal uses a <code>slope_map</code> (either specified or implied). 
</p>

<p>
  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 <code>accuracy &lt;float&gt;</code> to your normal. For all patterns, 
 the default is 0.02. 
</p>

<h4><a name="s03_05_02_02">3.5.2.2 </a>Normal Maps and Normal Lists</h4>
<a name="s03_05_02_02_i1"><a name="normal_map"></a>
<p>
  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 <code> normal_map</code>. The syntax for a <code>normal_map</code> is identical to a <code>pigment_map</code> 
 except you specify a <code> normal</code> in each map entry. The syntax for <code>normal_map</code> is as follows: 
</p>

<pre>
NORMAL_MAP:
    normal_map { NORMAL_MAP_BODY }
NORMAL_MAP_BODY:
    NORMAL_MAP_IDENTIFIER | NORMAL_MAP_ENTRY...
NORMAL_MAP_ENTRY:
    [ Value NORMAL_BODY ]
</pre>

<p>
  Where <em><code>Value</code></em> is a float value between 0.0 and 1.0 inclusive and each <em>NORMAL_BODY</em> is 
 anything which can be inside a <code>normal{...}</code> statement. The <code>normal</code> keyword and <code>{}</code> 
 braces need not be specified. 
</p>

<p class="Note">
  <strong>Note:</strong> that the <code>[]</code> brackets are part of the actual <em> NORMAL_MAP_ENTRY</em>. 
 They are not notational symbols denoting optional parts. The brackets surround each entry in the normal map. 
</p>

<p>
  There may be from 2 to 256 entries in the map. 
</p>

<p>
  For example 
</p>

<pre>
  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]
    }
  }
</pre>

<p>
  When the <code>gradient x</code> 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. 
</p>

<p>
  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. 
</p>

<p>
  A normal map is also used with the <code>average</code> normal type. See &quot;Average&quot; for details. 
</p>

<p>
  Entire normals in a normal list may also be used with the block patterns such as <code>checker</code>, <code>hexagon</code> 
 and <code>brick</code>. For example... 
</p>

<pre>
  normal {
    checker
    normal { gradient x scale .2 }
    normal { gradient y scale .2 }
  }
</pre>

<p class="Note">
  <strong>Note:</strong> in the case of block patterns the <code>normal</code> wrapping is required 
 around the normal information. 
</p>

<p>
  You may not use <code> normal_map</code> or individual normals with a <code> bump_map</code>. See section &quot;<a href="s_119.html#s03_05_05_01">Texture 
 Maps</a>&quot; for an alternative way to do this. 
</p>

<p>
  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. 
</p>

<h4><a name="s03_05_02_03">3.5.2.3 </a>Bump Maps</h4>
<a name="s03_05_02_03_i1"><a name="bump_map"></a>
<p>
  When all else fails and none of the above normal pattern types meets your needs you can use a <code>bump_map</code> 
 to wrap a 2-D bit-mapped bump pattern around your 3-D objects. 
</p>

<p>
  Instead of placing the color of the image on the shape like an <code> image_map</code> a <code>bump_map</code> 
 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 &quot;<a href="s_116.html#s03_05_02_03_03">Use_Index</a> and <a href="s_116.html#s03_05_02_03_03">Use_Color</a>&quot; 
 below). 
</p>

<h5><a name="s03_05_02_03_01">3.5.2.3.1 </a>Specifying a Bump Map</h5>

<p>
  The syntax for a <code>bump_map</code> is: 
</p>

<pre>
BUMP_MAP:
    normal
    {
        bump_map
        {
            BITMAP_TYPE &quot;bitmap.ext&quot;
            [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
</pre>

<p>
  After the required <em>BITMAP_TYPE</em> 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. 
</p>

<p class="Note">
  <strong>Note:</strong> earlier versions of POV-Ray allowed some modifiers before the <em>BITMAP_TYPE</em> 
 but that syntax is being phased out in favor of the syntax described here. 
</p>

<p class="Note">
  <strong>Note:</strong> <code>sys</code> format is a system-specific format such as BMP for Windows or 
 Pict for Macintosh. 
</p>

<p>
  Filenames specified in the <code>bump_map</code> 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 <code>+L</code> or <code> 
 Library_Path</code> options active. This would facilitate keeping all your bump maps files in a separate subdirectory 
 and giving a <code> Library_Path</code> option to specify where your library of bump maps are. See &quot;<a href="s_95.html#s03_01_02_05_04">Library 
 Paths</a>&quot; for details. 
</p>

<p>
  By default, the bump pattern is mapped onto the x-y-plane. The bump pattern is <em>projected</em> 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. 
</p>

<p>
  The file name is optionally followed by one or more <em> BITMAP_MODIFIERS</em>. The <code>bump_size</code>, <code> 
 use_color</code> and <code> use_index</code> modifiers are specific to bump maps and are discussed in the following 
 sections. See section &quot;<a href="s_126.html#s03_05_12_07">Bitmap Modifiers</a>&quot; for the generic bitmap 
 modifiers <code>map_type</code>, <code>once</code> and <code> interpolate</code> described in &quot;Bitmap 
 Modifiers&quot; 
</p>

<h5><a name="s03_05_02_03_02">3.5.2.3.2 </a>Bump_Size</h5>
<a name="s03_05_02_03_02_i1"><a name="bump_size"></a>
<p>
  The relative bump size can be scaled using the <code>bump_size</code> 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. 
</p>

<pre>
  normal {
    bump_map {
      gif &quot;stuff.gif&quot;
      bump_size 5.0
    }
  }
</pre>

<p>
  Originally <code>bump_size</code> 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: 
</p>

<pre>
  normal {
    My_Normal   //this is a previously defined normal identifier
    bump_size 2.0
  }
</pre>

<h5><a name="s03_05_02_03_03">3.5.2.3.3 </a>Use_Index and Use_Color</h5>
<a name="s03_05_02_03_03_i1"><a name="use_index"></a><a name="s03_05_02_03_03_i2"><a name="use_color"></a><a name="s03_05_02_03_03_i3"><a name="use_colour"></a>
<p>
  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 <code>use_index</code>, 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 <code>use_color</code> keyword may be specified to 
 explicitly note that the color methods should be used instead. The alternate spelling <code>use_colour</code> is also 
 valid. These modifiers may only be used inside the <code>bump_map</code> statement. 
</p>

<h4><a name="s03_05_02_04">3.5.2.4 </a>Scaling normals</h4>
<a name="s03_05_02_04_i1"><a name="no_bump_scale"></a>
<p>
  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 <code>no_bump_scale</code> 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. 
</p>

<p>
  It is also important to note that if you add <code>no_bump_scale</code> to a normal or texture that is contained 
 within another pattern (such as within a <code>texture_map</code> or <code>normal_map</code>), 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 <code>no_bump_scale</code> is specified at the top-level of the 
 texture (or normal, if the normal is not wrapped in a texture). 
</p>

<p>
 <a name="l143">
<small><strong>More about &quot;Pattern Modifiers&quot;</strong></small>
</a>
 <ul>
  
  <li><small>
   <a href="s_126.html#s03_05_12">3.5.12 Pattern Modifiers</a> in 3.5 Textures
  </small>

  <li><small>
   <a href="s_162.html#s03_08_10_08">3.8.10.8 Pattern Modifiers</a> in 3.8.10 Texture
  </small>

 </ul>

</p>
 <br> 
<table class="NavBar" width="100%">
  
 <tr>
   
  <td align="left" nowrap="" valign="middle" width="32">
    <a href="s_115.html"><img alt="previous" border="0" src="prev.png"></a> 
   
  </td>
   
  <td align="left" valign="middle" width="30%">
    <a href="s_115.html">3.5.1 Pigment</a> 
  </td>
   
  <td align="center" valign="middle">
    <strong>3.5.2 Normal</strong> 
  </td>
   
  <td align="right" valign="middle" width="30%">
    <a href="s_117.html">3.5.3 Finish</a> 
  </td>
   
  <td align="right" nowrap="" valign="middle" width="32">
    <a href="s_117.html"><img alt="next" border="0" src="next.png"></a> 
   
  </td>
   
 </tr>
  
</table>
 </body> </html>