Previous:Finite Patch Primitives Main Index Next:Disc

#### Bicubic Patch

A `bicubic_patch` is a 3D curved surface created from a mesh of triangles. POV-Ray supports a type of bicubic patch called a Bezier patch. A bicubic patch is defined as follows:

BICUBIC_PATCH:

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

The keyword `type` is followed by a float Patch_Type 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.

The four parameters `type`, `flatness`, `u_steps` and `v_steps` may appear in any order. All but `flatness` are 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 <Point_1>, <Point_4>, <Point_13> and <Point_16> 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 convex hull property.

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

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

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 `flatness` 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.

If the value for flatness is 0 POV-Ray will always subdivide the patch to the extend specified by `u_steps` and `v_steps`. 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.

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

- If the patch isn't very curved, then this will be detected and POV-Ray won't waste a lot of time looking at the wrong pieces.

- If the patch is only highly curved in a couple of places, POV-Ray will keep subdividing there and concentrate it's efforts on the hard part.

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.

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:

      bicubic_patch {

        type 0

        flatness 0.01

        u_steps 4

        v_steps 4

        <0, 0, 2>, <1, 0, 0>, <2, 0, 0>, <3, 0,-2>,

        <0, 1  0>, <1, 1, 0>, <2, 1, 0>, <3, 1, 0>,

        <0, 2, 0>, <1, 2, 0>, <2, 2, 0>, <3, 2, 0>,

        <0, 3, 2>, <1, 3, 0>, <2, 3, 0>, <3, 3, -2>

      }

The triangles in a POV-Ray `bicubic_patch` 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.

Previous:Finite Patch Primitives Main Index Next:Disc