Texture Space Mapping

These shaders take care of selecting, creating, and remapping texture spaces, computing basis vectors, and other tasks necessary before a color or displacement can be applied. Some of these functions have a select parameter that has one of the following values:

0..63	selects a texture vector. If this exceeds the number of defined texture spaces, default to -1 (the point in space). 2mm
-1	selects the 3D point in space directly, and may apply a space point transformation. 2mm
-2	selects the normal vector, and may apply a space vector transformation. 2mm
-3	selects the motion vector, and may apply a space vector transformation. 2mm
-4	selects the ray direction, and may apply a space vector transformation. 2mm
-5..-9	select a surface derivative vector, and may apply a space vector transformation. The values are , , , , and . The object must be defined to contain derivatives. 2mm
-10	selects a 2D background plate coordinate with (0, 0, 0) in the lower left corner of the screen, and (1, 1, 0) just outside the upper right corner of the screen. selspace has no effect in this mode. The transformation is similar to the one in mib_lookup_background. 2mm
-11	selects the texture coordinate in the state, where it is typically put by a material shader when evaluating a parameter of type texture, for use by a texture shader.

Space transformations allow transforming the vector that the projection is based on into object, world, or camera coordinates. selspace may have the following values:

0	does not apply a transformation, using internal space.
1	converts the vector into object space.
2	converts the vector into world space.
3	converts the vector into camera space.
4	returns the current screen space coordinates in the interval [0,0 ... 1,1).

An additional projection^2.1 can be applied to the resulting vector by setting the project parameter:

0	disables projections.
1	selects an UV projection if available.
2	selects an orthographic XY projection.
3	selects an orthographic XZ projection.
4	selects an orthographic YZ projection.
5	selects a spherical projection.
6	selects a cylindrical projection. U=0 is at +X, and V=0 is at +Y. Y is also the cylinder axis.
7	selects the lollipop projection, which puts the center of the texture (after texture vector normalization) at X=0.5 Z=1, and the corners at the parameter corners. On a sphere, the texture center is at the north pole and the texture corners are at the south pole, like a lollipop wrapper.

Texture Vertex Generator

Return a texture vector derived from orthographic projections of the 3D point in space (XY, XZ, YZ), non-orthographic projections (spherical or cylindrical); or return a numbered texture vector from the texture vector list. Optionally, this shader can base its calculations on object, camera, world, or screen space.

    vector "mib_texture_vector" (
        integer         "select",
        integer         "selspace",
        integer         "vertex",
        integer         "project")

select specifies the value to look up, as described above.

selspace allows choosing the source space for projections, as described above. Space conversion is done before the projection specified by the select parameter. If selspace is 4 (screen space), select, vertex, and project are ignored.

vertex specifies the location of the vertex: 0 is the intersection point, and 1, 2, and 3 are the vertices of the intersected triangle. It has no effect if select is -10.

project specifies a projection that is performed after selection and space conversion. It has no effect if select is -10.

Texture Vertex Remapping

Accepts a texture vertex and scales, rotates, translates, crops, and joins textures. The order of operations is transform first, then repeat, alternate, torus, and finally min/max crop. The result is returned (and stored in , where it can be picked up by other shaders).

    vector "mib_texture_remap" (
        vector          "input",
        transform       "transform",
        vector          "repeat",
        boolean         "alt_x",
        boolean         "alt_y",
        boolean         "alt_z",
        boolean         "torus_x",
        boolean         "torus_y",
        boolean         "torus_z",
        vector          "min",
        vector          "max",
        vector	        "offset")

input is a texture vector from a generator such as mib_texture_vector that returns texture vectors. input is overridden when this shader is called with a nonzero arg parameter in mi_call_shader_x. This is useful for remapping multiple texture coordinates when the remapping parameters are identical for all of them.

transform is a general transformation applied to the texture vector before the remaining parameters are applied. If transform[3][3] is 0.0, the matrix is ignored (normally transform[3][3] is 1.0).

repeat contains repetition factors in X, Y, and Z that the texture vector is multiplied with. A value of 2, for example, shrinks the texture such that it fits twice in the [0, 1) interval. Repeating has no effect outside this interval. After the multiplication by the repetition factor, the integer part is removed. This algorithm allows finite repetition in an interval determined by the transform parameter. A repetition value of 0 turns off repetition in the corresponding component, as if the value were 1.

alt_* specifies whether every other copy of the repetition would be reversed such that successive copies of the texture are traversed in alternate, back-and-forth directions. Alternate flags have an effect only if the corresponding repetition component is greater than 1, and also work only in the [0, 1) interval.

torus_* maps the texture space into the range [0, 1) such that values less than 0 and equal to or greater than 1 are put into this range by cutting off the integer part.

min and max implement image or volume cropping by specifying the range of the texture to be considered. Portions of the texture outside this range are trimmed off. If repetition is used, the max point of one copy joins the min point of the next copy (unless alternation is turned on). min is inclusive, max is exclusive. If a min component is equal to the corresponding max component, both are ignored.

offset is a vector added to the texture vector before the texture lookup.

Rotation of Surface Orientation

An angle is used to rotate the surface orientation around the surface normal. An orthogonal vector pair is returned that, together with the normal which both are orthogonal to, define the rotated orientation. This is especially useful for anisotropic reflection (see below).

    struct {
        vector          "u",
        vector          "v"
    } "mib_texture_rotate" (
        vector          "input",
        scalar          "angle",
        scalar          "min",
        scalar          "max")

u and v are the returned orthogonal vectors.

input is the texture vector to be rotated. It is expected in internal space.

angle is a scalar that is interpreted as a rotation. A value equal to min specifies no rotation, and a value equal to max specifies a 360-degree rotation. The angle can for example be the intensity from a texture lookup.

min and max specify the value limits corresponding to no and full rotation. An angle value is first mapped to . If min and max are both 0, they default to 0 and 0.25, corresponding to 0 and 90 degrees counter-clockwise.

Bump Basis Generator

Given the intersection point, compute a pair of bump basis vectors, based on the projection method (as above: UV, XY, XZ, YZ, spherical, or cylindrical).

    struct {
        vector          "u",
        vector          "v"
    } "mib_bump_basis" (
        integer         "project",
        integer         "ntex")

project specifies the projection to perform, as described above. All projections are based on the 3D point in space after conversion to object space. This parameter is used to orient the bump basis.

ntex is the texture space to use, in the range 0 ... 63. It is used only if project is UV (5) or disabled (0 or negative). Otherwise ntex is ignored.

Bump Mapping

Apply a texture to the normal vector by evaluating the texture at multiple points to compute U and V gradients that are multiplied with the basis vectors, combined with the original normal, normalized, and written back. Also return the normal. is left undefined.

    vector "mib_bump_map" (
        vector          "u",
        vector          "v",
        vector          "coord",
        vector          "step",
        scalar          "factor",
        boolean         "torus_u",
        boolean         "torus_v",
        boolean         "alpha",
        color texture   "tex",
        boolean         "clamp")

u and v are the bump basis vectors. They can be generated from another base shader such as mib_bump_basis.

coord is the texture coordinate for which the bump should be calculated.

step are offsets to coord. The shader samples three times: at (coord_x, coord_v), at (coord_x + step_x, coord_v), and at (coord_x, coord_v + step_v). The resulting U and V gradients are multiplied by the u and v basis vectors, respectively, then multiplied by the factor, and finally added to the normal, which is then renormalized. If the step components are 0, they default to 0.01.

factor controls the strength of the effect. If it is 0, it defaults to 1.

torus_u and torus_v specify that, when step is added to coord, the result (X, Y, and Z) should be wrapped back into the interval [0 ... 1).

alpha, if true, specifies that the alpha component instead of the intensity of the color texture should be used.

tex is a color texture or shader to look up three times. (Only use shader assignment using the "=" notation if the assigned shader returns a shader.)

clamp, if true, restricts bump mapping area to the [0, 1] texture coordinate range.

The following shader is identical to the previous, including the parameters, except that it returns a color instead of a vector. This color is not modified. This allows the shader to be used in material shader lists by prepending it to the actual material shader. In this configuration it is called first and modifies the normal vector in the state before the material shader uses it to compute illumination. At the same time, it does not in any way affect the computed result color.

    vector "mib_passthrough_bump_map" (
        vector          "u",
        vector          "v",
        vector          "coord",
        vector          "step",
        scalar          "factor",
        boolean         "torus_u",
        boolean         "torus_v",
        boolean         "alpha",
        color texture   "tex",
        boolean         "clamp")

See above for a description of the parameters.

mib_bump_map2

This is a different version of the bump map shader. It differs from the above by modifying the state->normal before calling the evaluation of color. Typically, the illumination shaders such as Phong should be connected to the color parameter. By modifying the normal in the beginning of the evaluation of the Phenomena, all connected nodes receive the perturbated normal.

The bump map will look at 3 texture samples from the texture, using the texture space 0. The differences of the 3 returned values indicate the bending of the normal. The normal will be bent in the direction of the bump_vectors if they exist, or in the direction of the derivatives otherwise. The modified normal is saved in the state before calling the evaluation of color. All shaders attached to color will then used this modified normal. The normal is set back to its original value at the end.

    
    color "mib_bump_map2" (
	scalar          "factor",
	scalar          "scale",
	color texture   "tex",
	color           "color"	)

factor deternimes how strong the bumps are.
scale determines how many times the bump map is repeated using the first texture coordinates.
tex specifies the texture to look up for the perturbation of the normal.
color is the color to attach illumination shaders to (e.g. Phong).