5.7 Kernels

The Sh library includes implementations of some standard program kernels. These are functions to generate parameterized shader objects. Kernel programs are designed to be used immediately, specialized, or combined with other kernels to build useful custom shaders using shader algebra operations.

Several design decisions were made in an attempt to keep the kernel library easy to use:

• Commonly curried inputs are placed at the beginning of the input list to reduce the need for the shExtract manipulator.
• All inputs and outputs are named (have name metadata attached) which allows manipulation and selection by name.
• Names for inputs and outputs that should be joined together on connection have the same name and type and are usually in the same order. This allows these kernels to be connected by position or by name without complex manipulator expressions.

In the following subsections, we will describe the available kernel generators. For each, we will give a list of input and output attributes each with their string names and positional ordering. Negative positions denote position from the end (-1 means last attribute, -2 means second last, etc.). Note that negative positions are accepted by manipulators.

Please note that some of the more complicated kernels described here may not be set in stone at this point in time, and may change in the future. Since the Shader Algebra is a fairly new addition to Sh, these kernels are still being developed and may not yet have the ideal interface for what they do.

5.7.1 Universal Vertex Shader Kernel

The shVsh kernel function is a generalized vertex program generator. It creates a “universal” vertex shader that can generates many common attributes required by fragment shaders. There are some construction parameters, but you can also just generate a shader with this function and then specialize it, for instance to discard the half vector or tangents if you don’t need them. Its definition is given as follows:

This function generates a program with the following inputs and outputs, which are given these precise names:

If num_tangents is 0, then tv and sv are not included in the inputs. In this case, no surface coordinate frame outputs will be included either. If num_tangents is 1, then only one tangent is given an input. In this case, sv is computed from the normal nv and the single tv. All surface coordinate outputs are valid. If num_tangent is greater than or equal to 2, then the first two tangents on the input are taken to define a surface coordinate frame, the rest are just transformed.

All other kernels in this section generate fragment shaders designed, generally, to interact with this particular vertex shader.

5.7.2 Surface Shader Kernels

These kernels implement various basic lighting models at the fragment level. These lighting models are actually defined in a coordinate-free manner and so. as long as all vectors are consistent, vectors in the VCS, MCS, or SCS can be used. To make it easier to plug shaders together, we drop the coordinate system suffix from names when the coordinate system does not matter.

Diffuse

The shDiffuse kernel function generates a fragment program for diffuse lighting. This does not do much, it just passes through the interpolated diffuse color given it on its input, after multiplying it by the irradiance color from the light source.

The specular kernel is coordinate system independent, so n, h, and lw can be in any space (as long as it is the same space for all three vectors).

Specular

The shBlinnPhongSpecular kernel function generates a fragment program that computes a Blinn-Phong highlight.

The specular kernel is coordinate system independent, so n, h, and lw can be in any space (as long as it is the same space for all three vectors).

Blinn-Phong

The shBlinnPhong kernel function generates a fragment program that combines the effects of the shDiffuse and shBlinnPhong kernels.

The phong kernel is coordinate system independent, so n, h, and lw can be in any space (as long as it is the same space for all three vectors).

Gooch

The shGooch kernel function generate a fragment program that computes Gooch illustrative shading [?].

The shGooch kernel is coordinate system independent, so n and lw can be in any space (as long as it is the same space for both).

Identity

The shIdentity kernel generates a surface shader that does nothing, just copies its irradiance to its output.

5.7.3 Light Shader Kernels

Light kernels are designed to be connected to the vertex shader outputs from a universal vertex shader. Each outputs one irrad output representing the irradiance at a surface of type T (usually ShColor3f).

Point Light Kernel

The shPointLight kernel builds a shader represents a point source.

Spot Light Kernel

The shSpotLight kernel builds a shader that has a linear falloff from the light vector in the same direction as the given direction vector to zero at the falloff angle.

Projector Light Kernel

This light source projects a texture onto a surface like a slide projector (except it does not itself handle shadows). This kernel is really a spotlight with a texture instead of a fixed falloff function.

5.7.4 Surface Map Kernels

These kernels modify some surface property.

SCS Bump Map Kernel

This takes a 2D gradient vector (usually acquired from a texture lookup, where the texture value in turn was obtained by differencing values in a height field) and the base normal represented relative to the surface coordinate space. It computes a perturbed normal represented relative to the surface coordinate space. Note that we do not use the space suffix to make it easier to hook this up to other shaders, but that it will only work with normals expressed relative to the SCS.

Bump Map Kernel

This does the same thing as SCS bump mapping, but in an arbitrary space (such as view space). It needs an explicit surface frame, because what it really has to do is transform the perturbed normal from the surface coordinate frame back out to the given coordinate frame. It computes the perturbed normal in the SCS then uses those coordinates to create a linear combination of the vectors in the given surface frame.

All vectors should be in the same space.

5.7.5 Postprocessing Kernels

These are postprocessing kernels, which modify the output color in some way, creating a new output color. Several postprocessing kernels can be connected together to create a more complicated postprocessing kernel.

Simple postprocessing kernels take an input of type T and return one output of type T named result. More complex postprocessing kernels might require extra information, such as the texture coordinates of each surface point, or the position.

Halftoning Kernel

The halftone function generates a kernel that performs halftoning/hatching independently in each color channel. A texture provided as an argument is tiled and used as a threshold image, / indexed by texture coordinates passed as inputs. A value of 1 is output if the input is larger than the corresponding component in the texture; otherwise, 0 is output. Intermediate values will also be output for halftoning (the threshold is actually a smooth step).

Noise-adding Kernel

The / shNoisify kernel function generates a shader that adds noise to some attribute, such as a rendered image.

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.