Procedural texture

(Redirected from Procedural textures)
A procedural floor grate texture generated with the texture editor Genetica.

A procedural texture is a computer-generated image created using an algorithm intended to create a realistic representation of natural elements such as wood, marble, granite, metal, stone, and others.

Usually, the natural look of the rendered result is achieved by the usage of fractal noise and turbulence functions. These functions are used as a numerical representation of the “randomness” found in nature.

Solid texturing

Solid texturing is a process where the texture generating function is evaluated over $R^3$ at each visible surface point of the model. Traditionally these functions use Simplex noise or Perlin noise as their basis function, but some simple functions may use more trivial methods such as the sum of sinusoidal functions for instance. Solid textures are an alternative to the traditional 2D texture images which are applied to the surfaces of a model. It is a difficult and tedious task to get multiple 2D textures to form a consistent visual appearance on a model without it looking obviously tiled. Solid textures were created to specifically solve this problem.

Instead of editing images to fit a model, a function is used to evaluate the colour of the point being textured. Points are evaluated based on their 3D position, not their 2D surface position. Consequently, solid textures are unaffected by distortions of the surface parameter space, such as you might see near the poles of a sphere. Also, continuity between the surface parameterization of adjacent patches isn’t a concern either. Solid textures will remain consistent and have features of constant size regardless of distortions in the surface coordinate systems. [1]

Cellular texturing

Cellular texturing differs from the majority of other procedural texture generating techniques as it does not depend on noise functions as its basis, although it is often used to complement the technique. Cellular textures are based on feature points which are scattered over a three-dimensional space. These points are then used to split up the space into small, randomly tiled regions called cells. These cells often look like “lizard scales,” “pebbles,” or “flagstones”. Even though these regions are discrete, the cellular basis function itself is continuous and can be evaluated anywhere in space. [2]

Genetic textures

Genetic texture generation is highly experimental approach for generating textures. It is a highly automated process that uses a human to completely moderate the eventual outcome. The flow of control usually has a computer generate a set of texture candidates. From these, a user picks a selection. The computer then generates another set of textures by mutating and crossing over elements of the user selected textures.[3] For more information on exactly how this mutation and cross over generation method is achieved, see Genetic algorithm. The process continues until a suitable texture for the user is generated. This isn't a commonly used method of generating textures as it’s very difficult to control and direct the eventual outcome. Because of this, it is typically used for experimentation or abstract textures only.

Self-organizing textures

Starting from a simple white noise, self-organization processes lead to structured patterns - still with a part of randomness. Reaction-diffusion systems are a good example to generate such kind of textures.

Example of a procedural marble texture

(Taken from The Renderman Companion Book, by Steve Upstill)

``` /* Copyrighted Pixar 1988 */
/* From the RenderMan Companion p. 355 */
/* Listing 16.19  Blue marble surface shader*/

/*
* blue_marble(): a marble stone texture in shades of blue
* surface
*/

blue_marble(
float   Ks    = .4,
Kd    = .6,
Ka    = .1,
roughness = .1,
txtscale = 1;
color   specularcolor = 1)
{
point PP;            /* scaled point in shader space */
float csp;           /* color spline parameter */
point Nf;            /* forward-facing normal */
point V;             /* for specular() */
float pixelsize, twice, scale, weight, turbulence;

/* Obtain a forward-facing normal for lighting calculations. */
Nf = faceforward( normalize(N), I);
V = normalize(-I);

/*
* Compute "turbulence" a la [PERLIN85]. Turbulence is a sum of
* "noise" components with a "fractal" 1/f power spectrum. It gives the
* visual impression of turbulent fluid flow (for example, as in the
* formation of blue_marble from molten color splines!). Use the
* surface element area in texture space to control the number of
* noise components so that the frequency content is appropriate
* to the scale. This prevents aliasing of the texture.
*/
PP = transform("shader", P) * txtscale;
pixelsize = sqrt(area(PP));
twice = 2 * pixelsize;
turbulence = 0;
for (scale = 1; scale > twice; scale /= 2)
turbulence += scale * noise(PP/scale);

if (scale > pixelsize) {
weight = (scale / pixelsize) - 1;
weight = clamp(weight, 0, 1);
turbulence += weight * scale * noise(PP/scale);
}

/*
* Magnify the upper part of the turbulence range 0.75:1
* to fill the range 0:1 and use it as the parameter of
* a color spline through various shades of blue.
*/
csp = clamp(4 * turbulence - 3, 0, 1);
Ci = color spline(csp,
color (0.25, 0.25, 0.35),      /* pale blue        */
color (0.25, 0.25, 0.35),  /* pale blue        */
color (0.20, 0.20, 0.30),  /* medium blue      */
color (0.20, 0.20, 0.30),  /* medium blue      */
color (0.20, 0.20, 0.30),  /* medium blue      */
color (0.25, 0.25, 0.35),  /* pale blue        */
color (0.25, 0.25, 0.35),  /* pale blue        */
color (0.15, 0.15, 0.26),  /* medium dark blue */
color (0.15, 0.15, 0.26),  /* medium dark blue */
color (0.10, 0.10, 0.20),  /* dark blue        */
color (0.10, 0.10, 0.20),  /* dark blue        */
color (0.25, 0.25, 0.35),  /* pale blue        */
color (0.10, 0.10, 0.20)   /* dark blue        */
);

/* Multiply this color by the diffusely reflected light. */
Ci *= Ka*ambient() + Kd*diffuse(Nf);

Oi = Os;
Ci = Ci * Oi;

/* Add in specular highlights. */
Ci += specularcolor * Ks * specular(Nf,V,roughness);
}
```