These shaders rely on one of the texture space mapping functions above
to produce the `coord` texture vertex, and produce a color for
that vertex. Shaders that produce 2D mappings only use the *x* and
*y* components of the texture vertex.

Most of these return colors. Since colors can be assigned to scalar parameters of other shaders, the shaders can be used in conjunction with blending shaders that select colors from a color spread based on a map scalar. This interacts with the fading and smoothing parameters of the texture shaders.

Look up a texture image in the half-open interval `[0, 1)`.
Points outside this interval are mapped to *R=G=B=A=0*.

color "mib_texture_lookup" ( color texture "tex", vector "coord")

- tex
- is the texture image to look up.
- coord
- is the coordinate to look up.

This is basically a front-end to the *mi_lookup_color_texture*
family of shader interface functions.

color "mib_texture_lookup2" ( color texture "tex", scalar "factor")

An alternative to *mib_texture_lookup*. This uses the first set
of texture coordinates in *state* instead of getting them as a
connected parameter.

- tex
- is the texture image to look up.
- factor
- is the repetition factor of the texture.

Lookup of texture image using elliptical filtering.

color "mib_texture_filter_lookup" ( color texture "tex", vector "coord", scalar "eccmax", scalar "maxminor", scalar "disc_r", boolean "bilinear", integer "space", shader "remap")

- tex
- is the texture image to look up. It must be a texture image, not a texture shader; otherwise the texture is looked up unfiltered.
- coord
- is the central texture sampling location.
- eccmax
- is the maximum allowed eccentricity for the ellipse.
- maxminor
- is the maximum number of texture pixels for the minor radius of the ellipse.
- disc_r
- is used in the calculation of screen-to-texture
space transformations. A default value of 0.3 is used if
`disc_r`is zero or unspecified. For scenes with highly curved surfaces it may be useful to choose a value in the range`(0.0...0.3]`if aliasing artifacts appear. - bilinear
- enables bilinear interpolation of texture samples if set to true. This blurs magnified areas and avoids blocky artifacts.
- space
- is the texture space index in the range
`[0...63]`. - remap
- is a shader that is called for remapping additional texture coordinates.

The shader calls *mi_texture_filter_project* with the
given *space* parameter to obtain three corresponding points
in raster and texture space. These three texture coordinates are
remapped by calling the specified *remap* shader; the actual
texture coordinate for remapping is passed as the fourth argument
of *mi_call_shader_x* (which means that the called shader
must be designed to check its fourth argument). The remapping
shader must use it instead of the provided texture coordinate
vector in the shader parameters.

The projection transformation matrix required by the filtered
texture lookup is calculated by calling the
*mi_texture_filter_transform* shader interface function,
using the three raster space and remapped texture space
coordinates. The translation component in the matrix is set to
`coord`. Note that the projection transformation is always
calculated for the current raster position, but it is possible to
translate the ellipse in texture space using *coord*. This
is useful for bump mapping.

This is basically a front-end to the *mi_lookup_filter_color_texture*
family of shader interface functions. The elliptical filter parameter
*bilinear* is set to false in *mib_texture_filter_lookup*, for
*circle_radius* the default value is used. If the projection matrix
cannot be calculated properly, or the texture is a shader instead of an image,
or the reflection level is not zero, nonfiltered texture lookup is used.

Divide the unit cube into eight subcubes, each with a separate RGBA color. The width of the left, bottom, and front part is programmable, allowing the use of this shader for generating stripes and two- or three-dimensional checkerboards. This function is also useful for preview shaderball scenes.

color "mib_texture_checkerboard" ( vector "coord", scalar "xsize", scalar "ysize", scalar "zsize", color "color000", color "color001", color "color010", color "color011", color "color100", color "color101", color "color110", color "color111")

- coord
- is the coordinate to texture.
- *size
- specifies the fraction of the left (x), bottom
(y), and front (z) half of the cube in each direction, in the
range
`[0, 1)`. - color***
- specifies the colors of the subcubes. The three digits stand for the XYZ coordinates: 000 is front lower left, and 100 is front lower right, and 111 is back upper right.

Draw a disc with programmable diameter into the unit square, and draw a sphere with programmable diameter into the unit cube. The foreground and background colors are programmable.

color "mib_texture_polkadot" ( vector "coord", scalar "radius", color "fgcolor", color "bgcolor")

color "mib_texture_polkasphere" ( vector "coord", scalar "radius", color "fgcolor", color "bgcolor")

- coord
- is the coordinate to texture.
- radius
- is the radius of the disc or sphere in the unit square or cube, respectively.
- fgcolor
- is the foreground color of the disc or sphere.
- bgcolor
- is the background color around the disc or sphere.

Create a turbulent scalar pattern in a unit cube. One, two, or all three texture vector components may be computed in polar coordinates, causing spherical mapping.

scalar "mib_texture_turbulence" ( vector "coord", scalar "spacing", scalar "strength", scalar "power", integer "iteration", integer "polar_dim")

- coord
- is the coordinate to texture.
- spacing
- is the density of the noise in the unit cube. If it is 0, a default of 1 is used.
- strength
- is a weight describing the strength of the distortion. If it is 0, a default of 1 is used.
- power
- specifies the degree of the turbulence. If it is 0, a default of 1 is used.
- iteration
- sets the number of composed turbulence passes, each of which contributes a diminishing amount of turbulence as specified by the power parameter. If it is 0, a default of 2 is used. The maximum is 8.
- polar_dim
- specifies the number of texture vector components that should be converted to polar coordinates before computing the compound noise value. 0 creates anisotropic noise, 1 creates lines, and 2 creates cylinders.

Create cosine waves in U, V, and W directions, each with a
programmable amplitude. (Frequency and offset can be controlled
using a texture remapping base shader.) The result is a grayscale
color, R=G=B=A, that can be remapped using a color map base shader.
Its range is `[o-s ... o+s]` if *s* is the sum
of the amplitudes and *o* is the offset.

color "mib_texture_wave" ( vector "coord", scalar "amplitude_x", scalar "amplitude_y", scalar "amplitude_z", scalar "offset")

- coord
- is the coordinate to texture.
- amplitude_*
- is a factor to multiply the generated wave with before adding it to the result. The defaults are 0 (no contribution).
- offset
- adds a constant value to the sum of the weighted cosines. This can be used to shift the result into the positive numbers.

Copyright © 1986, 2013 NVIDIA Corporation