Air Stream works well with the latest version of Maya, but you may need to perform one additional installation step if you wish Air Stream to automatically load when Maya starts:

Create an environment variable named MAYA_PLUG_IN_PATH and assign the full file path to the Air Stream plug-ins directory.  If the environment variable already exists, append the Air Stream plug-ins path to the list.

Air 12.09 introduces a new FakeCarpet surface shader that turns a simple rectangle into a patch of fuzzy carpet.  The carpet effect is produced by ray tracing a virtual field of carpet fibers inside the surface shader; no additional geometry is created in the scene.  This blog post provides a list of the required steps for creating fake carpet, followed by tips for tuning the shape, shading, and sampling parameters of the shader.

Getting Started

Here’s how to add carpet to a room model:

• Create a four-sided polygon and position it slightly above the floor.  The polygon should represent the top of the area to be covered by the carpet.  Make the polygon invisible to shadow rays.
• Assign the FakeCarpet surface shader.  You will probably want to disable the material preview window in your application when tuning this shader because the preview render can take a long time.
• Set the SizeX and SizeY parameters to the width and length of the carpet rectangle.  SizeX gives the size along the first texture coordinate axis, SizeY the size along the second texture coordinate axis.
• Set StrandLength to the length of the carpet fibers, which should be less than or equal to the height of the polygon above the floor.

That completes the the required steps to use the FakeCarpet shader.  You should then be able to render a test image of your scene and see some carpet.

Carpet Shape

The carpet is modeled as a grid of carpet fibers.  The geometric model of the fibers can be tuned using the following parameters:

StrandCount, StrandWidthFraction

The overall density of the fibers is set with StrandCount, which gives the number of fibers per unit length.  The diameter of a fiber is given by the StrandWidthFraction parameter as a fraction of the fiber length.

StrandTiltAngle, StrandTiltVary, StrandTiltFrequency, StrandStiffness
StrandPolarAngle, StrandPolarVary, StrandPolarFrequency

Individual fibers are represented as curved tubes.  StrandTiltAngle gives the average angle (in degrees) between the vertical direction and the tip of a fiber.  The tilt angle can be varied for each fiber using StrandTiltVary and StrandTiltFrequency.   StrandTiltFrequency is relative to the entire patch of carpet.  StrandStiffness controls how each fiber bends.  Higher values push the curve more toward the tip of each tube.

The direction of tilt can be changed using the StrandPolar parameters, which control a rotation in degrees about the vertical axis.

StrandSegments, TraceTip, TraceJoint

Each fiber is represented as a chain of tubular line segments.  StrandSegments gives the number of segments per fiber.  Each segment can be capped with a sphere.  TraceTip controls whether a sphere is traced at the tip of each fiber.  TraceJoints controls whether spheres are traced at the joints between segments in a fiber.

Carpet Shading

The carpet is shaded using an empirical model that assumes some light is reflected from the front of each fiber and some is transmitted.

FrontScatter, BackScatter, ScatterPower

FrontScatter gives the fraction of light reflected from the front of a fiber.  BackScatter gives the amount transmitted from behind.  Both are modulated based on the angle between the shading normal and the view direction such that more light is transmitted along the fiber edges and less in the middle.  The ScatterPower parameter is an exponent applied to the angle cosine used for this edge-based variation.

SelfShadowMax, ColorMapName, BaseColor, IndirectDiffuse

SelfShadowMax gives the maximum self-shadowing of the carpet (the shadowing effect of neighboring fibers).  Self-shadowing is greatest at the base of each fiber and smoothly attenuates to zero at the tip.

ColorMapName allows a color map to be applied to the fibers.

BaseColor gives the color of the “fabric” under the fibers, which is visible where fibers are missing.

IndirectDiffuse is a simple multiplier for the diffuse result returned for indirect illumination.  The shader does not trace fibers for indirect rays.

Carpet Trace Controls

The FakeCarpet shader performs ray tracing to determine which fibers are visible at each shading location.  The following parameters control this internal ray tracing process:

SampleGridSize

Because the carpet fibers will typically be much smaller than a pixel, the shader provides an option to trace multiple rays to produce a smoother, more accurate result.  SampleGridSize defines the size of an NxN grid of rays to trace at the current shading location.  The grid size is automatically reduced to 1 for reflection rays and IPR (interactive preview) rendering.

TraceMargin

The FakeCarpet shader treats the rectangular polygon as a sort of window into a virtual grid of 3D fibers.  There can be artifacts along the edges if this “window” clips the carpet.  To help prevent those artifacts, the TraceMargin parameter strips away a fraction of the fibers along the carpet border.  Larger values remove more rows of fibers.

TestForIntersections, TraceBias

TestForIntersections determines whether the shader checks for objects intersecting the carpet (such as a chair leg).  If there are no objects on the carpet, set this parameter to 0 to save some time and potentially avoid some artifacts.  The TraceBias parameter gives an offset used to avoid incorrect intersections in this test.

Final Remarks

The FakeCarpet surface is a fairly complicated shader, and you will likely need to experiment with the parameters to reproduce the appearance of a particular type of carpet.  An IPR session (utilizing TweakAir) can be used to interactively view the effects of parameter changes.

• Render time can be significantly slower because the area light shader must be evaluated at many different locations on the sphere to produce a smooth result.
• Some software (such as Massive) does not provide an interface for area lights.

To address those drawbacks we’ve put together a spherelight light shader that can be used to simulate the effect of a spherical light source using a standard point-type light.  Download the shader and sample scene files here:

http://www.sitexgraphics.com/spherelight.zip

The shader is very similar to the pointlight shader included with Air.  There is a new lightradius parameter for the radius of the (virtual) spherical light source.  The shader uses the light radius in a couple computations that approximate the effects of a spherical source:

1. Shadows are blurry close to the source and sharper farther away.  The shader simulates this effect by computing a shadow blur angle based on the distance to the light source and the light radius:

   lenL=max(sqrt(L.L),radius);
   blur = abs(atan(radius,sqrt(lenL*lenL-radius*radius)));
   

2. For locations close to the sphere surface, the light source no longer behaves as an idealized point light.  The shader accounts for this by supersampling the sphere surface (in the spherefactor() function) to account for the variation in incoming illumination from different parts of the sphere surface.

The images below compare the results for a true spherical area light (top)  with 64 light samples and the spherelight shader (bottom) using 64 shadow rays.

A user wants to import an object with both sharp edges and smooth edges into Massive for rendering with Air.   This should be easy except that Massive only allows one shading normal per vertex, and Massive automatically smooths any vertex that is shared by more than one face.

The Solution (reported by Air and Massive user Charlie Peterson)

In Maya separate the faces into two objects, to be exported as two separate OBJ files.   All faces that should appear flat with sharp edges go in one file; all faces that should appear smooth go in another.  For faces with sharp edges, each vertex must be unique; i.e., not shared with any other face in the model.  In Maya this can be accomplished by using the Detach Component action in the Edit Mesh menu.  The two sets of faces can then be exported as OBJ files without shading normals or smoothing groups.

Option 1:  Use a small options file with an imager shader to add a background image:

• Create a small text file with the following imager declaration:

Imager "VBackdrop" "string TextureName" "nameofbgimage.jpg"

• Enter the options rib file name as the “options rib include” entry in the ‘render parameters’ tab of the renders dialog.
• Drawback:  the imager shader will be included in the rib export for preview rendering and normal rendering.  If you do not wish to include the background image in final rendering, you’ll need to remove the options reference prior to exporting ribs for the final render.

Option 2:  Use Air Show to view the rendered preview image with a background plate

• Air Show has an option to display a rendered image over a background plate, but that option is only available for images with an alpha channel.  Unfortunately, the Massive preview image is always “rgb” only, so again this is not as easy as one might hope.
• A solution is to render the preview rib from a command shell and use Air’s command line options to override the output declaration to include an alpha channel.
• When rendering a preview image with Air, Massive exports the rib files and other data to $TEMP/massive.  To render the preview rib from a command shell:

cd $TEMP
cd massive
air -d -mode rgba massive.rib

• You can leave the command shell open and re-launch the last command for each preview.  Note that this means each preview will be rendered twice.  If the preview render takes more than a few seconds, you can use the red stop button in Air Show to abort the first preview render.
• To load the background image in Air Show, select Load Background from the View menu.  Use the checkered toolbar button to enable or disabled display of the background for the current image.

OceanWaves – displacement shader for the waves
OceanSurface – surface shader for deep ocean
OceanSurfaceWithForm – surface shader for deep ocean with foam at wave peaks

The following images use the ocean surface shaders along with the physical sky environment shader.

The underlying wave algorithm can simulate a variety of ocean conditions from calm seas to stormy waves depending on the wind speed:

The appearance of waves in windy conditions can be improved by adding chop, which sharpens wave peaks and stretches troughs by shifting the surface laterally:

Because the chop displacement shifts the surface in arbitrary directions, you’ll need to tell Air that the displacement is not strictly in the direction of the surface normal by applying the following attribute:

Attribute "render" "normaldisplacement" [0]

Note that too much chop can tear the surface apart.

Finally, the OceanSurfaceWithFoam surface shader allows foam to be rendered near wave peaks.  In order for the foam to appear in the proper location, the common parameters between the OceanWaves and OceanSurfaceWithFoam shaders must be set to the same values.

If you do not need to render foam, set the FoamEnabled parameter of the OceanWaves shader to 0 to reduce computation time for the waves.

Wave animation is controlled by the current frame number and the FramesPerSecond parameter value.

The waves can be tiled in X and Y; the above pictures are a 2×2 grid of the same wave pattern.

An Air point cloud is a simple binary file with a short header followed by a list of records, one record for each point.  Here’s the header:

typedef struct {
  char diName[48];
  int diType, diNarr, diIndex, diSize;
} DataInfo;

typedef struct {
  char id[4];
  unsigned int hsize;
  float gbound[6];
  float world2camera[16], world2ndc[16];
  int xres, yres;
  float par, fov;
  int flags;
  int maxdepth, maxleafsize;
  int nbrick, bricksize;
  int nbiv,npts;
  unsigned int ptoffset;
  float minwidth, maxwidth;
  int pad[256];
  int ndata,datasize;
  DataInfo di[64];
} AirPointHeader;

The ptoffset field gives the file position where the actual data begins.  The data for each point is stored as a binary array of floats with little-endian byte order.

Surface "ShowPosition"
 "float UnitSize" [1]
 "float[3] Origin" [0 0 0]
 "float Clamp" [0]
 "float Cyclic" [0]
 "string ShadingSpace" ["world"]

Here’s a rendering with the default parameter values.  The output color is the world-space x,y,z position of the current shading location:

It doesn’t normally make sense to filter position values, so this image was rendered with only 1 pixel sample (PixelSamples 1 1 in the RIB file) and no filtering.

The position values may well be greater than 1 or less than 0, so a full-precision position image should be saved in a file format such as HDR, EXR, or TIFF that supports floating-point data.

The ShowPosition shader also allows the position values to be scaled to lie in the unit interval, which allows the data to be recorded in an 8-bit or 16-bit image.  The scaling is performed by mapping the position into a cube with one corner defined by the Origin parameter and each side of length UnitSize.  In this image the UnitSize is set to 10:

Position values that lie outside of the box defined by the Origin and UnitSize value will be clamped to the unit interval if the Clamp parameter is set to 1.  If the Cyclic parameter is set to 1, out of range values will be wrapped to form a periodic pattern.  Here’s the same model with UnitSize set to 1 and Cyclic set to 1:

This new capability provides a simple solution to several common shading tasks that would otherwise require complex custom shaders:

• Decals:  apply an arbitrary number of texture maps to an object’s color and feed the result into any surface shader.

• Extra output variables:  add an arbitrary number of additional shaders to an object to produce extra output values without affecting the normal shading of the object.

• Assign different shaders to specific regions:  simple shader compositing allows existing surface shaders to be selectively applied to sections of a surface.

• Replicate application shader networks:  create arbitrary shader networks by connecting pre-compiled components.

Further, the implementation of networked and layered shaders does not require existing shaders to be re-written to take advantage of these new features.

This article describes how to use multiple shaders to address each of these tasks.  Sample shaders and rib files are included in the AIR distribution in:

$AIRHOME/examples/layers

Simple Color Layers

Here’s a simple RIB fragment that assigns multiple surface shaders to an object:

Surface "ColorMap" "string ColorMapName" "grid.tx"
Surface "+VMarble"

Prepending the shader name with “+” tells Air to append the shader to the list of shaders assigned to the object. The shaders are executed in the order in which they are assigned. Subsequent shaders inherit the current shading state (including the values of global variables) from shaders previously executed. Here’s a ColorMap shader that uses a texture map to set the object’s color value:

generic ColorMap(
  string ColorMapName = "";
  float SetColor = 1;
  output varying color __Color = 0;
)
{
  if (ColorMapName!="") {
    __Color = color texture(ColorMapName,s,t);
    if (SetColor!=0) Cs = __Color;
  }
}

In the RIB fragment given above, the VMarble shader will use the color map result as one of the input colors for the marble pattern. No modification of the VMarble shader is required.

The new generic shader type is compatible with any other shader type.  Generic shaders can be used to construct re-usable components for layered and networked shaders.

Sample scene: colormap.rib

Decals

The layers example directory includes a LayerDecal shader that applies a masked color to a surface. Simple sequential shader assignment allows an arbitrary number of decals to be applied to a surface without constructing a complex custom surface shader:

Surface "LayerDecal"
  "ColorMapName" "sitex.tx"
  "OriginXY" [.3 .67]
  "SizeXY" [-.3 -.3]
  "DecalColor" [1 1 1]
Surface "+LayerDecal"
  "ColorMapName" "sitex.tx"
  "OriginXY" [.25 .6]
  "SizeXY" [-.25 -0.25]
  "DecalColor" [1 0 0]
Surface "+plastic"

Sample scene: decals.rib

Extra Passes

Another task made easy with multiple shaders is adding extra output values to a rendering pass.   Air 11 includes a new generic shader that adds an occlusion output value to any surface (stored in a __occlusion output variable).   Sample usage:

 Display "extrapass.tif" "framebuffer" "rgba,color __occlusion"
...
Surface "VMarble"
Surface "+genOcclusion" "setshaderoutput" 0

Sample scene: extrapass.rib

Shader Compositing

Air’s multi-shader support includes an option to composite one shader on top of another. Here’s an example that adds a plastic decal to a metallic surface:

Surface "VMetal"
Surface "*VPlastic" "OpacityMapName" "sitex.tx" "ColorMapName" "square.tx"

The * before the shader name tells Air to blend the output color from the VPlastic shader with the output color of the VMetal shader using the output opacity from the VPlastic shader. Any output variables shared by the two shaders will also be composited using the output opacity.

Sample scene: compshaders1.rib

The above example shows how to composite a shader with controls for its output opacity. For surface shaders without opacity controls, an auxiliary shader can be used to control the opacity. Here is a simple generic shader that sets the global input opacity value:

generic OpacityMap(
  string OpacityMapName = "";
  output varying color __Opacity = 1;
)
{
  if (OpacityMapName!="") {
    __Opacity = color texture(OpacityMapName,s,t,"fill",-1);
    if (comp(__Opacity,1)==-1) __Opacity=comp(__Opacity,0);
    Os = __Opacity;
  }
}

This shader allows any surface shader that modulates its output color by the input opacity to be composited over another shader.  Most surface shaders modulate their output color in this way.

Here is how the OpacityMap shader might be used to add a marble decal to a 2D grid:

Surface "VGrid2D"
Surface "+OpacityMap" "OpacityMapName" "sitex.tx"
Surface "*VMarble"

To optimize the evaluation of composited shaders, Air will skip any shader layer whose input opacity value is 0.

Sample scene: compshaders2.rib

Shader Networks

Multiple shaders can be used to re-construct a general shader network by defining connections among the shaders assigned to an object. Connections are defined by including additional parameters in the shader declaration. First, each shader declaration is assigned a name using:

“string layername” “componentname“

Naturally layername does not need to be an actual parameter of the shader.

Each connection is defined with an additional string parameter:

“string connect:toparametername” “fromlayer:fromparametername“

The connection transfers the value of fromparametername in layer fromlayer to the target parameter in the current shader.  The source parameter must be an output variable of the source shader or a global shader variable.  The target parameter is normally one of the shader’s input parameters, but it can also be the global input color (Cs) or input opacity (Os).  The source and target parameters must have the same type.

Sample usage:

Surface "ColorMap"
  "string ColorMapName" "grid.tx"
  "float SetColor" [0]
  "layername" "gridlayer"
Surface "+VMarble"
  "connect:VeinColor" "gridlayer:__Color"

In this example, the marble vein color is taken from the ColorMap shader’s __Color output variable.

Applications

The Air Stream plug-in for Maya uses the new shader network capability in Air 11 to translate Maya’s shader networks for rendering with Air.  This approach also easily allows:

• Air shader parameters to be driven by a Maya shading network
• Air shaders and Maya shaders to be mixed in a single network
• Air custom shading language functions to be incorporated in a Maya shading network using generic shaders

We need a function that allows us to look up a set of values based on a name, like looking up a word’s definition in a dictionary.   We can add such a function to Air’s shading language by implementing a dynamic shadeop, or DSO for short, which will be loaded by Air automatically and used to evaluate our new function.

The dictionary DSO adds the following new functions to the shading language:

float dictionary(string dictname, string keyname, float fvalue);
float dictionary(string dictname, string keyname, color cvalue);
float dictionary(string dictname, string keyname, string svalue);

The dictionary function looks for a text file named dictname and tries to load a list of token value pairs, one per line.  The token values should look like

Seattle 47.45 -122.3 -8

The functions return 0 if they succeed.  If an error occurs, the functions return one of the following error codes:

-1:  unable to find or read dictionary file
-2:  key name not found
-3:  unable to convert value to the requested type

Since Air 11 has not yet been released, here are a couple other uses for the dictionary function that you can try with the current Air release.

The first example uses the dictionary function to allow the base surface color to be specified using a name instead of r,g,b values.  The Air distribution includes a list of named colors in $AIRHOME/vizools/colors.txt (used by the Air Space tool).  Here’s the source code for a simple NamedColor shader:

surface NamedColor(
 float Ambient = 1;
 float Diffuse = 1;
 string ColorName = "";
 string ColorList = "$AIRHOME/viztools/colors.txt"
)
{
  color Ct = Cs;
  if (ColorName!="") dictionary(ColorList,ColorName,Ct);
  normal Nf = faceforward (normalize(N),I);
  Oi = Os;
  Ci = Oi * Ct * (Ambient * ambient() + Diffuse * diffuse(Nf));
}

The dictionary function will expand the reference to the $AIRHOME environment variable in the ColorList value.

In a RIB file, we can then specify a named color as:

Surface "NamedColor"
 "string ColorName" "neon pink"

Another application for the dictionary function is to allow simple text files to be used to define “preset” values for a shader’s parameters.  Here’s an extended version of the standard paintedplastic surface shader with an option to use a file with preset values:

surface paintedplasticpreset(
 float Ka = 1;
 float Kd = .5;
 float Ks = .5;
 float roughness = .1;
 color specularcolor = 1;
 string texturename = "";
 string preset = "";
)
{
 float preKa=Ka;
 float preKd=Kd;
 float preKs=Ks;
 float preroughness = roughness;
 color prespecularcolor=specularcolor;
 string pretexturename=texturename;

 if (preset!="") {
  dictionary(preset,"Ka",preKa);
  dictionary(preset,"Kd",preKd);
  dictionary(preset,"Ks",preKs);
  dictionary(preset,"roughness",preroughness);
  dictionary(preset,"specularcolor",prespecularcolor);
  dictionary(preset,"texturename",pretexturename);
 }
 Ci = Cs;
 if (pretexturename != "")     Ci *= color texture(pretexturename);
 normal Nf = faceforward (normalize(N),I);
 Oi = Os;
 Ci = Oi * Ci * (preKa*ambient() + preKd*diffuse(Nf)) + prespecularcolor * preKs*specular(Nf,-normalize(I),preroughness);
}

A sample preset file might look like:

Kd 0.4
Ks 0.6
roughness 0.2
specularcolor = 1 1 0
texturename = grid.tx

The new dictionary shadeop can found in this archive.  Unzip the archive to the AIRHOME directory, and the new shadop will automatically be added to the shaders directory of your Air installation (where Air can find it).  Examples and source code for the shadeop can be found in $AIRHOME/examples/dictionary.