Connecting and combining existing programs using the algebra operators can result in redundant computation. The optimizer can only do so much, especially if redundant inputs or outputs are present or the same computation is expressed in different ways.
Fortunately, the “<<” operator, in conjunction with the optimizer in the Sh compiler (particularly dead code removal) and the definition of some simple “glue” programs, can be used to specialize program objects and eliminate redundant computation.
For instance, suppose we combine two program objects and the resulting program computes the same value twice (in two different ways, so we cannot discover this fact automatically). We can define a simple program that copies its inputs to its outputs except for one of the redundant results. This “discard” program can be connected to the output of the combined shader and the Sh dead code eliminator will remove the redundant computation.
Nibbles are functions that build and return small ShPrograms that support primitive but useful operations. These primitives can be used to glue together other program objects, or even to generate new programs from scratch. You can combine nibbles using the shader algebra operators to generate many useful programs. The shader algebra operators provide a functional language and the nibbles are the basic functions from which other functions can be built.
The supported interface manipulation nibbles include the following:
Combinations of keep, lose, and dup with “&” can be used to describe mappings that retain or make copies of a subset of outputs.
Sh also provides manipulator versions of this functionality, described in Section 5.6. To distinguish the two, the nibbles use a lower-case naming convention like that of the standard library rather than the sh prefix convention used by other nibbles. You should use the manipulator versions if you want to avoid specifying type information. Also, manipulators are available for specifying general swizzles, extractions, and insertions.
The shOutputPass nibble function generates a passthrough program that copies the outputs of a given ShProgram and keeps all the names. This is like the keep nibble, but it uses a program as an argument and can generate a glue program with different type on different channels. The shInputPass function does the same thing for the inputs of a given ShProgram. This is useful in cases where vertex shader outputs need to be duplicated before being passed to the fragment shader.
The shAccess nibble generates an ShProgram that takes a texture coordinate as input and performs a texture lookup. The return type of the lookup is the storage type of the texture. The shAccess nibble is overloaded on all built-in texture types, as shown below in Listing ??.
The casting nibble shCast generates a program that casts an input of tuple type T to type T2. If the number of elements of T is less than the number of elements of T2, this nibble pads the result tuple with 0 components at the end. If the opposite is true, it truncates the result tuple. In other words, it has the same behaviour as the cast library function.
The fill-casting nibble shFillcast casts from tuple type T to type T2, with the same semantics as the fillcast library function. If the number of elements in T is less than the number of elements in T2, the generated program pads with repeated last component at end.
The transformation nibble shTransform creates an ShProgram that transforms a variable of type T2 by a matrix of type ShMatrix<Rows, Cols, Binding, T>.
The basis conversion nibble function shChangeBasis generates a program that takes 3 vectors defining an orthonormal basis and projects the fourth vector onto them, returning the coordinates of the vector in the new basis.
There are also nibbles corresponding to /
all unary library functions and
operators. These nibbles all have one input and one output. By default the input
is named "x" and the output is named "result" (although both can
be configured). For example, nibbles for shAbs, shCos, shAcos, shSin,
shAsin, shFrac, shSqrt, shNeg (negate), shNormalize, and shPos all
exist. All the unary nibbles have similar interfaces. We only give one:
Nibbles are also defined for / all of the binary library functions and
operators. These nibbles all have two inputs and one output. By default the first
input is named "x", the second input is named "y", and the output is named
"result" (although all three can be configured). For example, shAdd,
shSub, shMul, shDiv, shDot, shPow, shSlt, shSle, shSgt, shSge, shSeq,
shSne, shFmod, shMin, and shMax are all defined. Note in particular the
names of the boolean functions (set less-than, set less-than-or-equal,
etc.). All the binary nibbles have similar interfaces. We only give one:
Lastly, trinary functions also have corresponding nibbles, in particular shLerp and shCond . The shLerp has two type parameters, the type of the interpolation parameter and the type of the value to be interpolated. If only one type is given, these are assumed to be the same.
shCond takes two type parameters, the type of the conditional and the type of the two values to choose from. Again, these are assumed to be the same by default.
Note: This manual is available as a bound book from AK Peters, including better formatting, in-depth examples, and about 200 pages not available on-line.