File: s_106.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 (664 lines) | stat: -rw-r--r-- 26,751 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.4.2 Finite Patch Primitives</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_105.html"><img alt="previous" border="0" src="prev.png"></a> 
   
  </td>
   
  <td align="left" valign="middle" width="30%">
    <a href="s_105.html">3.4.1 Finite Solid Primitives</a> 
  </td>
   
  <td align="center" valign="middle">
    <strong class="NavBar">POV-Ray 3.6 for UNIX documentation</strong><br> <strong>3.4.2 
   Finite Patch Primitives</strong> 
  </td>
   
  <td align="right" valign="middle" width="30%">
    <a href="s_107.html">3.4.3 Infinite Solid Primitives</a> 
  </td>
   
  <td align="right" nowrap="" valign="middle" width="32">
    <a href="s_107.html"><img alt="next" border="0" src="next.png"></a> 
   
  </td>
   
 </tr>
  
</table>
 
<h3><a name="s03_04_02">3.4.2 </a>Finite Patch Primitives</h3>

<p>
  There are six totally thin, finite objects which have no well-defined inside. They are bicubic patch, disc, smooth 
 triangle, triangle, polygon and mesh / mesh2. They may be combined in CSG union but cannot be used in other types of 
 CSG (or inside a <code>clipped_by</code> statement). Because these types are finite POV-Ray can use automatic bounding 
 on them to speed up rendering time. As with all shapes they can be translated, rotated and scaled. 
</p>

<h4><a name="s03_04_02_01">3.4.2.1 </a>Bicubic Patch</h4>
<a name="s03_04_02_01_i1"><a name="bezier"></a><a name="s03_04_02_01_i2"><a name="s03_04_02_01_i3"><a name="bicubic_patch"></a><a name="s03_04_02_01_i4"><a name="bicubic_patch, keyword"></a><a name="s03_04_02_01_i5"><a name="s03_04_02_01_i6"><a name="type, bicubic_patch"></a><a name="s03_04_02_01_i7"><a name="s03_04_02_01_i8"><a name="u_steps, bicubic_patch"></a><a name="s03_04_02_01_i9"><a name="s03_04_02_01_i10"><a name="v_steps, bicubic_patch"></a><a name="s03_04_02_01_i11"><a name="s03_04_02_01_i12"><a name="flatness, bicubic_patch"></a><a name="s03_04_02_01_i13">
<p>
  A <code>bicubic_patch</code> is a 3D curved surface created from a mesh of triangles. POV-Ray supports a type of 
 bicubic patch called a <em>Bezier patch</em>. A bicubic patch is defined as follows: 
</p>

<pre>
BICUBIC_PATCH:
    bicubic_patch
    {
        PATCH_ITEMS...
        &lt;Point_1&gt;,&lt;Point_2&gt;,&lt;Point_3&gt;,&lt;Point_4&gt;,
        &lt;Point_5&gt;,&lt;Point_6&gt;,&lt;Point_7&gt;,&lt;Point_8&gt;,
        &lt;Point_9&gt;,&lt;Point_10&gt;,&lt;Point_11&gt;,&lt;Point_12&gt;,
        &lt;Point_13&gt;,&lt;Point_14&gt;,&lt;Point_15&gt;,&lt;Point_16&gt;
        [OBJECT_MODIFIERS...]
    }
PATCH_ITEMS:
    type Patch_Type | u_steps Num_U_Steps | v_steps Num_V_Steps |
    flatness Flatness
</pre>

<p>
  Bicubic patch default values: <a name="s03_04_02_01_i14"> 
</p>

<pre>
flatness : 0.0
u_steps  : 0
v_steps  : 0
</pre>
<a name="s03_04_02_01_i15"><a name="type"></a>
<p>
  The keyword <code>type</code> is followed by a float <em><code> Patch_Type</code></em> which currently must be 
 either 0 or 1. For type 0 only the control points are retained within POV-Ray. This means that a minimal amount of 
 memory is needed but POV-Ray will need to perform many extra calculations when trying to render the patch. Type 1 
 preprocesses the patch into many subpatches. This results in a significant speedup in rendering at the cost of memory. 
</p>

<p>
  <a name="s03_04_02_01_i16"><a name="flatness"></a><a name="s03_04_02_01_i17"><a name="u_steps"></a><a name="s03_04_02_01_i18"><a name="v_steps"></a> 
 The four parameters <code>type</code>, <code> flatness</code>, <code> u_steps</code> and <code>v_steps</code> may 
 appear in any order. Only <code>type</code> is required. They are followed by 16 vectors (4 rows of 4) that define the 
 x, y, z coordinates of the 16 control points which define the patch. The patch touches the four corner points <em><code> 
 &lt;Point_1&gt;</code></em>, <em><code> &lt;Point_4&gt;</code></em>, <em> <code>&lt;Point_13&gt;</code></em> and <em> <code> 
 &lt;Point_16&gt;</code></em> while the other 12 points pull and stretch the patch into shape. The Bezier surface is 
 enclosed by the convex hull formed by the 16 control points, this is known as the <em>convex hull property</em>. 
</p>

<p>
  The keywords <code>u_steps</code> and <code>v_steps</code> are each followed by integer values which tell how many 
 rows and columns of triangles are the minimum to use to create the surface, both default to 0. The maximum number of 
 individual pieces of the patch that are tested by POV-Ray can be calculated from the following: <em>pieces = 2^u_steps 
 * 2^v_steps</em>. 
</p>

<p>
  This means that you really should keep <code>u_steps</code> and <code> v_steps</code> under 4. Most patches look 
 just fine with <code>u_steps 3</code> and <code>v_steps 3</code>, which translates to 64 subpatches (128 smooth 
 triangles). 
</p>

<p>
  As POV-Ray processes the Bezier patch it makes a test of the current piece of the patch to see if it is flat enough 
 to just pretend it is a rectangle. The statement that controls this test is specified with the <code> flatness</code> 
 keyword followed by a float. Typical flatness values range from 0 to 1 (the lower the slower). The default if none is 
 specified is 0.0. 
</p>

<p>
  If the value for flatness is 0 POV-Ray will always subdivide the patch to the extend specified by <code>u_steps</code> 
 and <code>v_steps</code>. If flatness is greater than 0 then every time the patch is split, POV-Ray will check to see 
 if there is any need to split further. 
</p>

<p>
  There are both advantages and disadvantages to using a non-zero flatness. The advantages include: 
</p>

<p>
  - If the patch is not very curved, then this will be detected and POV-Ray will not waste a lot of time looking at 
 the wrong pieces. 
</p>

<p>
  - If the patch is only highly curved in a couple of places, POV-Ray will keep subdividing there and concentrate its 
 efforts on the hard part. 
</p>

<p>
  The biggest disadvantage is that if POV-Ray stops subdividing at a particular level on one part of the patch and at 
 a different level on an adjacent part of the patch there is the potential for cracking. This is typically visible as 
 spots within the patch where you can see through. How bad this appears depends very highly on the angle at which you 
 are viewing the patch. 
</p>

<p>
  Like triangles, the bicubic patch is not meant to be generated by hand. These shapes should be created by a special 
 utility. You may be able to acquire utilities to generate these shapes from the same source from which you obtained 
 POV-Ray. Here is an example: 
</p>

<pre>
  bicubic_patch {
    type 0
    flatness 0.01
    u_steps 4
    v_steps 4
    &lt;0, 0, 2&gt;, &lt;1, 0, 0&gt;, &lt;2, 0, 0&gt;, &lt;3, 0,-2&gt;,
    &lt;0, 1  0&gt;, &lt;1, 1, 0&gt;, &lt;2, 1, 0&gt;, &lt;3, 1, 0&gt;,
    &lt;0, 2, 0&gt;, &lt;1, 2, 0&gt;, &lt;2, 2, 0&gt;, &lt;3, 2, 0&gt;,
    &lt;0, 3, 2&gt;, &lt;1, 3, 0&gt;, &lt;2, 3, 0&gt;, &lt;3, 3, -2&gt;
  }
</pre>

<p>
  The triangles in a POV-Ray <code>bicubic_patch</code> are automatically smoothed using normal interpolation but it 
 is up to the user (or the user's utility program) to create control points which smoothly stitch together groups of 
 patches. 
</p>

<h4><a name="s03_04_02_02">3.4.2.2 </a>Disc</h4>
<a name="s03_04_02_02_i1"><a name="disc"></a><a name="s03_04_02_02_i2"><a name="disc, keyword"></a><a name="s03_04_02_02_i3">
<p>
  Another flat, finite object available with POV-Ray is the <code> disc</code>. The disc is infinitely thin, it has 
 no thickness. If you want a disc with true thickness you should use a very short cylinder. A disc shape may be defined 
 by: 
</p>

<pre>
DISC:
    disc
    {
        &lt;Center&gt;, &lt;Normal&gt;, Radius [, Hole_Radius]
        [OBJECT_MODIFIERS...]
    }
</pre>

<p>
  Disc default values: <a name="s03_04_02_02_i4"> 
</p>

<pre>
HOLE RADIUS : 0.0
</pre>

<p>
  The vector <em><code>&lt;Center&gt;</code></em> defines the x, y, z coordinates of the center of the disc. The <em><code> 
 &lt;Normal&gt;</code></em> vector describes its orientation by describing its surface normal vector. This is followed 
 by a float specifying the <em> <code> Radius</code></em>. This may be optionally followed by another float specifying 
 the radius of a hole to be cut from the center of the disc. 
</p>

<p class="Note">
  <strong>Note:</strong> The inside of a disc is the inside of the plane that contains the disc. Also 
 note that it is not constrained by the radius of the disc. 
</p>

<h4><a name="s03_04_02_03">3.4.2.3 </a>Mesh</h4>
<a name="s03_04_02_03_i1"><a name="mesh"></a><a name="s03_04_02_03_i2"><a name="mesh, keyword"></a><a name="s03_04_02_03_i3"><a name="s03_04_02_03_i4"><a name="uv_vectors, mesh"></a><a name="s03_04_02_03_i5"><a name="s03_04_02_03_i6"><a name="texture_list, mesh"></a><a name="s03_04_02_03_i7"><a name="s03_04_02_03_i8"><a name="inside_vector, mesh"></a><a name="s03_04_02_03_i9"><a name="s03_04_02_03_i10"><a name="triangle, mesh"></a><a name="s03_04_02_03_i11"><a name="s03_04_02_03_i12"><a name="smooth_triangle, mesh"></a><a name="s03_04_02_03_i13"><a name="s03_04_02_03_i14"><a name="hierarchy, mesh"></a><a name="s03_04_02_03_i15">
<p>
  The <code>mesh</code> object can be used to efficiently store large numbers of triangles. Its syntax is: 
</p>

<pre>
MESH:
    mesh
    {
        MESH_TRIANGLE...
        [MESH_MODIFIER...]
    }
MESH_TRIANGLE:
    triangle
    {
        &lt;Corner_1&gt;, &lt;Corner_2&gt;, &lt;Corner_3&gt;
        [uv_vectors &lt;uv_Corner_1&gt;, &lt;uv_Corner_2&gt;, &lt;uv_Corner_3&gt;]
        [MESH_TEXTURE]
    } |
    smooth_triangle
    {
        &lt;Corner_1&gt;, &lt;Normal_1&gt;,
        &lt;Corner_2&gt;, &lt;Normal_2&gt;,
        &lt;Corner_3&gt;, &lt;Normal_3&gt;
        [uv_vectors &lt;uv_Corner_1&gt;, &lt;uv_Corner_2&gt;, &lt;uv_Corner_3&gt;]
        [MESH_TEXTURE]
    }
MESH_TEXTURE:
  texture { TEXTURE_IDENTIFIER }
  texture_list {
    TEXTURE_IDENTIFIER TEXTURE_IDENTIFIER TEXTURE_IDENTIFIER
  }

MESH_MODIFIER:
    inside_vector &lt;direction&gt; | hierarchy [ Boolean ] |
    OBJECT_MODIFIER
</pre>

<p>
  Mesh default values: <a name="s03_04_02_03_i16"> 
</p>

<pre>
hierarchy : on
</pre>

<p>
  Any number of <code>triangle</code> and/or <code>smooth_triangle</code> statements can be used and each of those 
 triangles can be individually textured by assigning a texture identifier to it. The texture has to be declared before 
 the mesh is parsed. It is not possible to use texture definitions inside the triangle or smooth triangle statements. 
 This is a restriction that is necessary for an efficient storage of the assigned textures. See &quot;<a href="s_106.html#s03_04_02_06">Triangle 
 and Smooth Triangle</a>&quot; for more information on triangles. 
</p>

<p>
  The <code>mesh</code> object can support <code>uv_mapping</code>. For this, per triangle the keyword <code>uv_vectors</code> 
 has to be given, together with three 2D uv-vectors. Each vector specifies a location in the xy-plane from which the 
 texture has to be mapped to the matching points of the triangle. Also see the section <a href="#l133">uv_mapping</a>. 
</p>

<p>
  <a name="s03_04_02_03_i17"> The mesh's components are internally bounded by a bounding box hierarchy to speed up 
 intersection testing. The bounding hierarchy can be turned off with the <code>hierarchy off</code> keyword. This 
 should only be done if memory is short or the mesh consists of only a few triangles. The default is <code>hierarchy on</code>. 
 
</p>

<p>
  Copies of a mesh object refer to the same triangle data and thus consume very little memory. You can easily trace a 
 hundred copies of a 10000 triangle mesh without running out of memory (assuming the first mesh fits into memory). The 
 mesh object has two advantages over a union of triangles: it needs less memory and it is transformed faster. The 
 memory requirements are reduced by efficiently storing the triangles vertices and normals. The parsing time for 
 transformed meshes is reduced because only the mesh object has to be transformed and not every single triangle as it 
 is necessary for unions. 
</p>

<p>
  The mesh object can currently only include triangle and smooth triangle components. That restriction may change, 
 allowing polygonal components, at some point in the future. 
</p>

<h5><a name="s03_04_02_03_01">3.4.2.3.1 </a>Solid Mesh</h5>
<a name="s03_04_02_03_01_i1"><a name="inside_vector"></a><a name="s03_04_02_03_01_i2">
<p>
  Triangle mesh objects (<code>mesh</code> and <code>mesh2</code>) can now be used in CSG objects such as difference 
 and intersect, because, after adding <code>inside_vector</code>, they do have a defined 'inside'. This will only work 
 for well-behaved meshes, which are completely closed volumes. If meshes have any holes in them, this might work, but 
 the results are not guaranteed. 
</p>

<p>
  To determine if a point is inside a triangle mesh, POV-Ray shoots a ray from the point in some arbitrary direction. 
 If this vector intersects an odd number of triangles, the point is inside the mesh. If it intersects an even number of 
 triangles, the point is outside of the mesh. You can specify the direction of this vector. For example, to use <code>+z</code> 
 as the direction, you would add the following line to the triangle mesh description (following all other mesh data, 
 but before the object modifiers). 
</p>

<pre>
  inside_vector &lt;0, 0, 1&gt;
</pre>

<p>
  This change does not have any effect on unions of triangles... these will still be always hollow. 
</p>

<h4><a name="s03_04_02_04">3.4.2.4 </a>Mesh2</h4>
<a name="s03_04_02_04_i1"><a name="vertex_vectors"></a><a name="s03_04_02_04_i2"><a name="normal_vectors"></a><a name="s03_04_02_04_i3"><a name="uv_vectors"></a><a name="s03_04_02_04_i4"><a name="face_indices"></a><a name="s03_04_02_04_i5"><a name="normal_indices"></a><a name="s03_04_02_04_i6"><a name="uv_indices"></a><a name="s03_04_02_04_i7"><a name="texture-list"></a><a name="s03_04_02_04_i8"><a name="mesh2"></a><a name="s03_04_02_04_i9"><a name="mesh2, keyword"></a><a name="s03_04_02_04_i10"><a name="s03_04_02_04_i11"><a name="vertex_vectors, mesh2"></a><a name="s03_04_02_04_i12"><a name="s03_04_02_04_i13"><a name="normal_vectors, mesh2"></a><a name="s03_04_02_04_i14"><a name="s03_04_02_04_i15"><a name="uv_vectors, mesh2"></a><a name="s03_04_02_04_i16"><a name="s03_04_02_04_i17"><a name="texture_list, mesh2"></a><a name="s03_04_02_04_i18"><a name="s03_04_02_04_i19"><a name="face_indices, mesh2"></a><a name="s03_04_02_04_i20"><a name="s03_04_02_04_i21"><a name="normal_indices, mesh2"></a><a name="s03_04_02_04_i22"><a name="s03_04_02_04_i23"><a name="uv_indices, mesh2"></a><a name="s03_04_02_04_i24"><a name="s03_04_02_04_i25"><a name="inside_vector, mesh2"></a><a name="s03_04_02_04_i26">
<p>
  The new mesh syntax is designed for use in conversion from other file formats. 
</p>

<pre>
  MESH2 :
      mesh2{
        VECTORS...
        LISTS...   |
        INDICES... |
        MESH_MODIFIERS
      }
  VECTORS :
      vertex_vectors 
      {
        number_of_vertices,
        &lt;vertex1&gt;, &lt;vertex2&gt;, ...
      }|
      normal_vectors 
      {
        number_of_normals,
        &lt;normal1&gt;, &lt;normal2&gt;, ...
      }|
      uv_vectors 
      {
        number_of_uv_vectors,
        &lt;uv_vect1&gt;, &lt;uv_vect2&gt;, ...
      }
  LISTS :
      texture_list 
      {
        number_of_textures,
        texture { Texture1 },
        texture { Texture2 }, ...
      }|
  INDICES :
      face_indices 
      {
        number_of_faces,
        &lt;index_a, index_b, index_c&gt; [,texture_index [,
                                    texture_index, texture_index]],
        &lt;index_d, index_e, index_f&gt; [,texture_index [,
                                    texture_index, texture_index]],
        ...
      }|
      normal_indices 
      {
        number_of_faces,
        &lt;index_a, index_b, index_c&gt;,
        &lt;index_d, index_e, index_f&gt;,
        ...
      }|
      uv_indices {
        number_of_faces,
        &lt;index_a, index_b, index_c&gt;,
        &lt;index_d, index_e, index_f&gt;,
        ...
      }
  MESH_MODIFIER :
      inside_vector &lt;direction&gt; | OBJECT_MODIFIERS
</pre>

<p>
  <code>mesh2</code> has to be specified in the order <em>VECTORS...</em>, <em>LISTS...</em>, <em>INDICES...</em>. 
 The <code>normal_vectors</code>, <code>uv_vectors</code>, and <code>texture_list</code> sections are optional. If the 
 number of normals equals the number of vertices then the normal_indices section is optional and the indexes from the <code>face_indices</code> 
 section are used instead. Likewise for the <code>uv_indices</code> section. 
</p>

<p class="Note">
  <strong>Note:</strong> that the numbers of uv_indices must equal number of faces. 
</p>

<p>
  The indexes are ZERO-BASED! So the first item in each list has an index of zero. 
</p>

<h5><a name="s03_04_02_04_01">3.4.2.4.1 </a>Smooth and Flat triangles in the same mesh</h5>

<p>
  You can specify both flat and smooth triangles in the same mesh. To do this, specify the smooth triangles first in 
 the <code>face_indices</code> section, followed by the flat triangles. Then, specify normal indices (in the <code>normal_indices</code> 
 section) for only the smooth triangles. Any remaining triangles that do not have normal indices associated with them 
 will be assumed to be flat triangles. 
</p>

<h5><a name="s03_04_02_04_02">3.4.2.4.2 </a>Mesh Triangle Textures</h5>

<p>
  To specify a texture for an individual mesh triangle, specify a single integer texture index following the 
 face-index vector for that triangle. 
</p>

<p>
  To specify three textures for vertex-texture interpolation, specify three integer texture indices (separated by 
 commas) following the face-index vector for that triangle. 
</p>

<p>
  Vertex-texture interpolation and textures for an individual triangle can be mixed in the same mesh 
</p>

<h4><a name="s03_04_02_05">3.4.2.5 </a>Polygon</h4>
<a name="s03_04_02_05_i1"><a name="polygon"></a><a name="s03_04_02_05_i2"><a name="polygon, keyword"></a><a name="s03_04_02_05_i3">
<p>
  The <code>polygon</code> object is useful for creating rectangles, squares and other planar shapes with more than 
 three edges. Their syntax is: 
</p>

<pre>
POLYGON:
    polygon
    {
        Number_Of_Points, &lt;Point_1&gt; &lt;Point_2&gt;... &lt;Point_n&gt;
        [OBJECT_MODIFIER...]
    }
</pre>

<p>
  The float <em><code>Number_Of_Points</code></em> tells how many points are used to define the polygon. The points <em><code> 
 &lt;Point_1&gt;</code></em> through <em><code>&lt;Point_n&gt;</code></em> describe the polygon or polygons. A polygon 
 can contain any number of sub-polygons, either overlapping or not. In places where an even number of polygons overlaps 
 a hole appears. When you repeat the first point of a sub-polygon, it closes it and starts a new sub-polygon's point 
 sequence. This means that all points of a sub-polygon are different. 
</p>

<p>
  If the last sub-polygon is not closed a warning is issued and the program automatically closes the polygon. This is 
 useful because polygons imported from other programs may not be closed, i.e. their first and last point are not the 
 same. 
</p>

<p>
  All points of a polygon are three-dimensional vectors that have to lay on the same plane. If this is not the case 
 an error occurs. It is common to use two-dimensional vectors to describe the polygon. POV-Ray assumes that the z value 
 is zero in this case. 
</p>

<p>
  A square polygon that matches the default planar image map is simply: 
</p>

<pre>
  polygon {
    4,
    &lt;0, 0&gt;, &lt;0, 1&gt;, &lt;1, 1&gt;, &lt;1, 0&gt;
    texture {
      finish { ambient 1 diffuse 0 }
      pigment { image_map { gif &quot;test.gif&quot;  } }
    }
    //scale and rotate as needed here
  }
</pre>

<p>
  The sub-polygon feature can be used to generate complex shapes like the letter &quot;P&quot;, where a hole is cut 
 into another polygon: 
</p>

<pre>
  #declare P = polygon {
    12,
    &lt;0, 0&gt;, &lt;0, 6&gt;, &lt;4, 6&gt;, &lt;4, 3&gt;, &lt;1, 3&gt;, &lt;1,0&gt;, &lt;0, 0&gt;, 
    &lt;1, 4&gt;, &lt;1, 5&gt;, &lt;3, 5&gt;, &lt;3, 4&gt;, &lt;1, 4&gt;
  }
</pre>

<p>
  The first sub-polygon (on the first line) describes the outer shape of the letter &quot;P&quot;. The second 
 sub-polygon (on the second line) describes the rectangular hole that is cut in the top of the letter &quot;P&quot;. 
 Both rectangles are closed, i.e. their first and last points are the same. 
</p>

<p>
  The feature of cutting holes into a polygon is based on the polygon inside/outside test used. A point is considered 
 to be inside a polygon if a straight line drawn from this point in an arbitrary direction crosses an odd number of 
 edges (this is known as <em>Jordan's curve theorem</em>). 
</p>

<p>
  Another very complex example showing one large triangle with three small holes and three separate, small triangles 
 is given below: 
</p>

<pre>
  polygon {
    28,
    &lt;0, 0&gt; &lt;1, 0&gt; &lt;0, 1&gt; &lt;0, 0&gt;          // large outer triangle
    &lt;.3, .7&gt; &lt;.4, .7&gt; &lt;.3, .8&gt; &lt;.3, .7&gt;  // small outer triangle #1
    &lt;.5, .5&gt; &lt;.6, .5&gt; &lt;.5, .6&gt; &lt;.5, .5&gt;  // small outer triangle #2
    &lt;.7, .3&gt; &lt;.8, .3&gt; &lt;.7, .4&gt; &lt;.7, .3&gt;  // small outer triangle #3
    &lt;.5, .2&gt; &lt;.6, .2&gt; &lt;.5, .3&gt; &lt;.5, .2&gt;  // inner triangle #1
    &lt;.2, .5&gt; &lt;.3, .5&gt; &lt;.2, .6&gt; &lt;.2, .5&gt;  // inner triangle #2
    &lt;.1, .1&gt; &lt;.2, .1&gt; &lt;.1, .2&gt; &lt;.1, .1&gt;  // inner triangle #3
  }
</pre>

<h4><a name="s03_04_02_06">3.4.2.6 </a>Triangle and Smooth Triangle</h4>
<a name="s03_04_02_06_i1"><a name="triangle"></a><a name="s03_04_02_06_i2"><a name="triangle, keyword"></a><a name="s03_04_02_06_i3">
<p>
  The <code>triangle</code> primitive is available in order to make more complex objects than the built-in shapes 
 will permit. Triangles are usually not created by hand but are converted from other files or generated by utilities. A 
 triangle is defined by 
</p>

<pre>
TRIANGLE:
    triangle
    {
        &lt;Corner_1&gt;, &lt;Corner_2&gt;, &lt;Corner_3&gt;
        [OBJECT_MODIFIER...]
    }
</pre>

<p>
  where <em><code>&lt;Corner_n&gt;</code></em> is a vector defining the x, y, z coordinates of each corner of the 
 triangle. 
</p>

<p>
  Because triangles are perfectly flat surfaces it would require extremely large numbers of very small triangles to 
 approximate a smooth, curved surface. However much of our perception of smooth surfaces is dependent upon the way 
 light and shading is done. By artificially modifying the surface normals we can simulate a smooth surface and hide the 
 sharp-edged seams between individual triangles. 
</p>

<p>
  <a name="s03_04_02_06_i4"><a name="smooth_triangle"></a><a name="s03_04_02_06_i5"><a name="smooth_triangle, keyword"></a> 
 <a name="s03_04_02_06_i6"> The <code>smooth_triangle</code> primitive is used for just such purposes. The smooth 
 triangles use a formula called Phong normal interpolation to calculate the surface normal for any point on the 
 triangle based on normal vectors which you define for the three corners. This makes the triangle appear to be a smooth 
 curved surface. A smooth triangle is defined by 
</p>

<pre>
SMOOTH_TRIANGLE:
    smooth_triangle
    {
        &lt;Corner_1&gt;, &lt;Normal_1&gt;, &lt;Corner_2&gt;,
        &lt;Normal_2&gt;, &lt;Corner_3&gt;, &lt;Normal_3&gt;
        [OBJECT_MODIFIER...]
    }
</pre>

<p>
  where the corners are defined as in regular triangles and <em><code> &lt;Normal_n&gt;</code></em> is a vector 
 describing the direction of the surface normal at each corner. 
</p>

<p>
  These normal vectors are prohibitively difficult to compute by hand. Therefore smooth triangles are almost always 
 generated by utility programs. To achieve smooth results, any triangles which share a common vertex should have the 
 same normal vector at that vertex. Generally the smoothed normal should be the average of all the actual normals of 
 the triangles which share that point. 
</p>

<p>
  The <code> mesh</code> object is a way to combine many <code>triangle</code> and <code>smooth_triangle</code> 
 objects together in a very efficient way. See &quot;<a href="#l134">Mesh</a>&quot; for details. 
</p>

<p>
 <a name="l133">
<small><strong>More about &quot;uv_mapping&quot;</strong></small>
</a>
 <ul>
  
  <li><small>
   <a href="s_121.html#s03_05_07">3.5.7 UV Mapping</a> in 3.5 Textures
  </small>

  <li><small>
   <a href="s_161.html#s03_08_09_01">3.8.9.1 UV Mapping</a> in 3.8.9 Object Modifiers
  </small>

 </ul>

</p>

<p>
 <a name="l134">
<small><strong>More about &quot;Mesh&quot;</strong></small>
</a>
 <ul>
  
  <li><small>
   <a href="s_106.html#s03_04_02_03">3.4.2.3 Mesh</a> in 3.4.2 Finite Patch Primitives
  </small>

  <li><small>
   <a href="s_106.html#s03_04_02_04">3.4.2.4 Mesh2</a> in 3.4.2 Finite Patch Primitives
  </small>

 </ul>

</p>
 <br> 
<table class="NavBar" width="100%">
  
 <tr>
   
  <td align="left" nowrap="" valign="middle" width="32">
    <a href="s_105.html"><img alt="previous" border="0" src="prev.png"></a> 
   
  </td>
   
  <td align="left" valign="middle" width="30%">
    <a href="s_105.html">3.4.1 Finite Solid Primitives</a> 
  </td>
   
  <td align="center" valign="middle">
    <strong>3.4.2 Finite Patch Primitives</strong> 
  </td>
   
  <td align="right" valign="middle" width="30%">
    <a href="s_107.html">3.4.3 Infinite Solid Primitives</a> 
  </td>
   
  <td align="right" nowrap="" valign="middle" width="32">
    <a href="s_107.html"><img alt="next" border="0" src="next.png"></a> 
   
  </td>
   
 </tr>
  
</table>
 </body> </html>