Procedural texture - Citizendia

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. Computer animation Computer-generated imagery (also known as CGI) is the application of the field of Computer graphics or more specifically 3D computer graphics In Mathematics, Computing, Linguistics and related subjects an algorithm is a sequence of finite instructions often used for Calculation Wood is hard fibrous lignified structural tissue produced as secondary Xylem in the stems of Woody plants notably trees but also shrubs Marble is a nonfoliated Metamorphic rock resulting from the Metamorphism of Limestone, composed mostly of Calcite (a crystalline form of Granite (ˈɡrænɪt is a common and widely occurring type of intrusive, Felsic, igneous rock. The M acro E xpansion T emplate A ttribute L anguage complements TAL, providing macros which allow the reuse of code across In Geology, rock is a naturally occurring aggregate of Minerals and/or Mineraloids The Earth's outer solid layer the ‘ Lithosphere

Usually, the natural look of the rendered result is achieved by the usage of fractal noise and turbulence functions. A fractal is generally "a rough or fragmented geometric shape that can be split into parts each of which is (at least approximately a reduced-size copy of the whole" is a one volume manga created by Tsutomu Nihei as a prequel to his ten-volume work Blame!. In Fluid dynamics, turbulence or turbulent flow is a fluid regime characterized by chaotic Stochastic property changes The Mathematical concept of a function expresses dependence between two quantities one of which is given (the independent variable, argument of the function These functions are used as a numerical representation of the “randomness” found in everything that surrounds us. A number is an Abstract object, tokens of which are Symbols used in Counting and measuring. Randomness is a lack of order Purpose, cause, or predictability

In general, these noise and fractal functions are simply used to “disturb” the texture in a natural way such as the undulations of the veins of the wood. In other cases, like marbles' textures, they are based on the graphical representation of fractal noise.

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);

   /* Gradual fade out of highest-frequency component near limit */
   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);

   /* Adjust for opacity.  */
   Oi = Os;
   Ci = Ci * Oi;

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

This article was taken from The Photoshop Roadmap with written authorization

Example of a procedural marble texture:

See also