|
|
| (One intermediate revision by one other user not shown) |
| Line 1: |
Line 1: |
| [[Image:Procedural Texture.jpg|225px|right|thumb|A procedural floor grate texture generated with the texture editor [http://www.spiralgraphics.biz/gallery.htm Genetica].]]
| | My name is Jenni and I am studying Art and Earth Sciences at Rotterdam / Netherlands.<br><br>Here is my web-site; [http://www.amazon.com/Manifesting-Unlimited-Money-Law-Attraction-ebook/dp/B00LMGPELG Manifesting Unlimited Money Using LOA] |
| | |
| <!-- Missing image removed: [[Image:Cellule render1.jpg|225px|right|thumb|A procedural cellular pattern generated with [http://cellule.homeip.net Cellule].]] -->
| |
| 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]], [[rock (geology)|stone]], and others.
| |
| | |
| Usually, the natural look of the rendered result is achieved by the usage of [[fractal]] [[noise]] and [[turbulence]] [[function (mathematics)|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 <math>R^3</math> at each visible surface point of the model. Traditionally these functions use [[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.
| |
| <ref>Ebert et al: ''Texturing and Modeling A Procedural Approach'', page 10. Morgan Kaufmann, 2003.</ref>
| |
| | |
| ==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.
| |
| <ref>Ebert et al: ''Texturing and Modeling A Procedural Approach'', page 135. Morgan Kaufmann, 2003.</ref> | |
| | |
| ==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.<ref>Ebert et al: ''Texturing and Modeling A Procedural Approach'', page 547. Morgan Kaufmann, 2003.</ref> 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)
| |
| | |
| <pre>
| |
| /* 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);
| |
| }
| |
| </pre>
| |
| | |
| ''This article was taken from [http://www.photoshoproadmap.com The Photoshop Roadmap] with written authorization''
| |
| | |
| ==See also==
| |
| {{Portal|Computer graphics}}
| |
| *[[Texture synthesis]]
| |
| *[[Texture artist]]
| |
| *[[Procedural generation]]
| |
| *[[Perlin noise]]
| |
| *[[Self-organization]]
| |
| | |
| ==References==
| |
| <!-- See http://en.wikipedia.org/wiki/Wikipedia:Footnotes for tips on adding references using <ref> tags -->
| |
| {{Reflist}}
| |
| | |
| <!-- Cellular textures: http://www.cs.brown.edu/research/vis/docs/pdf/Fleischer-1995-CTG.pdf -->
| |
| <!-- Solid and genetic textures: http://www.amazon.com/Texturing-Modeling-Procedural-Approach-Kaufmann/dp/1558608486 -->
| |
| | |
| ==Some programs for creating textures using procedural texturing==
| |
| *[[Allegorithmic Substance Designer]]
| |
| *[[Filter Forge]]
| |
| *[[Genetica (program)|''Genetica'' (program)]] [http://www.spiralgraphics.biz/genetica.htm]
| |
| *[[DarkTree]] [http://www.darksim.com/html/dt25_description.html]
| |
| *[[Context Free Art]] [http://www.contextfreeart.org/index.html]
| |
| *[[TexRD]] [http://www.texrd.com] (based on reaction-diffusion: self-organizing textures)
| |
| *[[Texture Garden]] [http://texturegarden.com]
| |
| *[[Enhance Textures]] [http://www.shaders.co.uk]
| |
| | |
| [[Category:3D computer graphics]]
| |
| | |
| [[nl:Procedurele_generatie]]
| |
| [[de:Prozedurale Synthese]]
| |