Appendix C. Glossary

Absolute Data Point

When the pureMix of an absolute dataPoint changes, the dataPoint keeps its appearance by adjusting its correction. That means when you have an absolute combination dataPoint and change a plain dataPoint that influences it, the combination dataPoint will not inherit the changes. When you set the weights so that the combination is reached, the deformed object looks exactly as before the change.

Absolute Geometry

Absolute geometry displays a dataPoint’s absolute data (i.e., how the deformed object looks when the dataPoint is reached).

You can show the edit and/or the view geometry for any dataPoint. Each can either be relative or absolute independently from the dataPoint’s mode.

AU

See FACS.

BCS

BCS stands for BlendShape Combination System. It is the tool this whole manual is all about.

In short, the BCS is a deformation system that was designed for high-end facial setups. More information can be found in Chapter 1. Introduction and Chapter 5. How the System Works.

BCS Node

This is the node that implements the bcs in Maya. It is managed by the bcs command, which is used by the UI.

Bilateral Data Point

A bilateral dataPoint is a dataPoint that has at least one bilateral weight in its position. For each bilateral dataPoint you can specify the falloff it should use. A bilateral dataPoint has three versions - a left, a right, and a complete (bilateral) version. What you model is the bilateral part of the dataPoint. The left and right sub-dataPoints are created for you by the node, using the specified falloff.

You are not limited to modeling the bilateral part. When more control is needed than editing the falloff, you can also edit the two unilateral sub-dataPoints. They are edited independently from each other and don’t even influence the bilateral part.

Bilateral Weight

Any weight can be made bilateral. A bilateral weight has two values, a left and a right. Other weights have just one.

Border Position

A border position is a weightPosition with a position that is either above 0 and the last, or below 0 and the first in a wPosGrp. This means that each wPosGrp has one or two border positions. In most cases, a weight has one border position at its value 1.

Combination-Sculpting

This term was used by Bay Raitt to describe the method he used for the facial rigs of the characters in The Lord Of The Rings trilogy.

Corrective Deltas

Even though you usually edit the absolute data of a dataPoint, internally, only the change to the pureMix of the dataPoint is used. This change is the correction the dataPoint contains and adds to the deformation.

Data Point (dp)

DataPoints are the deformation knots of the bcs.

Data Point Group (dpg)

All dataPoints that use weightPositions of the same weights are grouped together in what I called a dataPointGroup. Thus, all dataPoints in a group have the same number of weights in their position.

A dataPointGroup has no immediate influence on the system. It just groups dataPoints that use weightPositions of the same weights. These dataPointGroups are also used in the UI to visually group related dataPoints. The dataPoints in a group are sorted based on the positions they use, so that a dataPoint with the positions 1.0*0.5 comes after a dataPoint with the position 0.5*1.0.

Data Point Mode

A dataPoint can be relative, absolute, or instanced. This is called its mode.

Data Point Position

To know how much a dataPoint should influence the deformation, it has to be connected to one or more weights. This is called positioning a dataPoint because this way it gets a place in the weightSpace. The position consists of one or more weightPositions (all from different weights, of course).

Deformation

Deformation is the process of taking an object and changing it by moving its points around using certain rules. In Maya, nodes deform objects by taking the no-yet-deformed neutral geometry as an input and producing an output geometry using their own data and methods. The output geometry then goes into the displayed shape. Therefore, you just see the deformed object and not the input object.

Maya also allows for construction history. This means that the input geometry is not necessarily the neutral shape. It can also be an object that has already been worked on by other nodes. It also means that the output geometry of the deformation node doesn’t need to be fed directly into the displayed shape. It itself can be plugged into further nodes. The last of those nodes is connected to the shape that you will see in the scene.

DPK

My name… DPK.. it’s Daniel Pook-Kolb, mind you ;)

Edit Geometry

Edit geometry is the interface to the data of a dataPoint. You use it to model a dataPoint with any modeling tools you like. It can be compared to the objects you have as blendShape targets.

In the bcs, edit geometry can edit two different types of data in a dataPoint. The absolute geometry is used to exactly define how you want the object to look when the dataPoint is reached (i.e., when the weights are set to its position). The internally stored relative data of the dataPoint will be updated accordingly.

You use relative geometry to directly edit the correction the dataPoint adds to its pureMix when it is reached. This will be of little use in most cases.

Empty Position

A dataPoint position that consists of no weightPositions is an empty position. Placing a dataPoint there will make it unreachable, no matter how you set the weights. It can be used to temporarily store dataPoints for re-using them later. Note that this is the only position at which more than one dataPoint can exist.

You might consider writing a script that will handle different versions of dataPoints by storing the unused ones in this empty position.

FACS

FACS stands for Facial Action Coding System and has become a standard in understanding facial behavior. It was developed by Paul Ekman, Wallace V. Friesen and Joseph C. Hager.

FACS divides all possible facial movements in Action Units (AUs). These are based on the musculature of the face. The different AUs are not divided muscle by muscle because certain muscles always contract together (e.g. AU 4) while other muscles can contract partly (e.g. AUs 1 and 2).

Understanding facial movement is crucial to building a successful facial rig. For this reason, I highly recommend taking a look, or better, studying the FACS Manual. Their web site can be found here:
http://face-and-emotion.com/dataface/facs/description.jsp

Falloff

In the bcs, a falloff is a curve that is used to create the left and right versions of a bilateral dataPoint. Falloffs are stored in the bcs node and can be managed in the Falloff Settings part of the bcs UI. You can have any number of falloffs.

Falloff Axis

If you use automatic left-right separation to create sub-dataPoints, the falloff of a dataPoint is applied across this axis. If your character faces in z-direction, use X as the falloff axis.

Inbetween Data Point

A dataPoint that is positioned at an inbetween position is an inbetween dataPoint.

Inbetween Position

A weightPosition that is not a border position is an inbetween position. It is used to place dataPoints at weight values that are not at the weight’s maximum value.

Note that a dataPoint position involving inbetween weightPositions is also called an inbetween position.

Input Geometry

The input or neutral geometry is the object that goes into the bcs node. Out comes the deformed geometry (output geometry). The input geometry cannot be changed by the bcs node. It represents the neutral state (when no dataPoint is active).

Instance Target

The dataPoint of which an instanced dataPoint is the instance of. A special instance target is the neutral geometry.

Instanced Data Point

An instanced dataPoint is a copy of another dataPoint (called its instance target). It will always have the same absolute data as its target dataPoint even when this is changed directly or indirectly.

Instances cannot be edited using geometry, since they derive their data from their instance target. Of course, view geometry can be created for instances.

A special case is when the instanced dataPoint is bilateral but its target dataPoint isn’t. In this case, you can specify a falloff that will be used to create the unilateral sub-dataPoints of the instance.

Neutral Geometry

See Input Geometry.

Plain Data Point

A dataPoint with a plain position.

Plain Position

This is a special case of a dataPoint position where only one weight is used (and only when its weightPosition at the value 1 is used). Furthermore, the weightPosition has to be on the main layer (0). A dataPoint with a plain position behaves just like a blendShape target and is controlled directly with the one weight that defines its position.

If the wPos has certain interpolation settings or isn’t the only one on the main layer, the connection between the dataPoint and the weight isn’t linear. In this case, the behavior isn’t exactly as a blendShape target.

Pure Mix

Every dataPoint has a pureMix. It is the deformation that would be the result when the position of the dataPoint is reached but the dataPoint wasn’t there.

The pureMix of a plain dataPoint is zero. Combination dataPoints and inbetween dataPoints on sub-layered weightPositions have a non-zero pureMix (at least when the other dataPoints contain any deltas).

Relative Data Point

A relative dataPoint just stores the correction it adds to its pureMix. If the pureMix of a relative dataPoint changes, the dataPoint inherits the changes. This means that when the dataPoint is reached, the deformation looks different than before.

Relative Geometry

Relative geometry displays a dataPoint’s relative data. This is the correction that is added to the deformation by the dataPoint.

You can show the edit and/or the view geometry for any dataPoint. Each can either be relative or absolute independently from the dataPoint’s mode.

Separation Pattern

Since bilateral weights have two values, we need a name for the left and one for the right attribute. The two separation patterns are used to automatically create these names. One separation pattern consists of a string that contains a ‘%s’. This will be replaced by the weight’s name.

For example, if the two separation patterns are ‘%sL’ for left and ‘%sR’ for right names and we have a bilateral weight called ‘smile’, the two value names will be ‘smileL’ and ‘smileR’. Changing the ‘%sL’ pattern to ‘l_%s’ results in a left name of ‘l_smile’.

Separation String

Even though the names are similar, a separation string has nothing to do with the separation patterns. The separation string is just used by the UI. In dataPoint lists, dpGroups of combination dataPoints have names that consist of the weights used by the dataPoints. These weights are listed one after the other, separated by this separation string. That’s it.

Sub-Data Points

A bilateral dataPoint has three parts: the left, the right, and the main (or complete). The left and right are the unilateral the main is the bilateral part. The unilateral parts are sometimes referred to as sub-dataPoints.

View Geometry

Each dataPoint can have view geometry. This is geometry that doesn’t affect or edit the dataPoint. It’s just there so that you can see the data of a dataPoint. It can be useful (or funny) to see the relative geometry while editing the absolute. View geometry has the advantage that it can be relative or absolute without affecting the mode of the dataPoint.

Note that changes you make to the view geometry do not change the dataPoint in any way.

Weight

Weights are the animatable attributes that represent the interface between the user and the node and thus control the whole deformation. In the acs, they were called inputs, but since this word is reserved for deformers ( inputs are the original objects that are being deformed), we use the term of the blendShape node: weight.

Each weight has one value if it isn’t bilateral (bilateral weights have two, a left and a right). With these values, you define the current position in the weightSpace. This position is then used together with the positions of all the dataPoints to calculate how much each dataPoint affects the deformation.

Weight Position (wPos)

A wPos makes a certain value (position) of a weight available for dataPoint positions.

Weight Position Group (wpg)

A wPosGrp allows you to create different setups of weightPositions for one weight. Note that dataPoints of the same dataPointGroup have to use weightPositions from the same wPosGrps. Thus, combination dataPoints can use weightPositions of wpg 2 while plain dataPoints can use wpg 1. Combination dataPoints involving different weights than the wpg 2 ones can use wpg 0. Of course, one wPosGrp can be used by any number of dpGrps.

Let’s say you have several dataPointGroups using weightPositions of wpg 1 and you want to separate them, so that one group still uses wpg 1 and another a new wpg. This could be done by first duplicating wpg 1 and selecting the new wPosGrp. Next, you’d select the dataPointGroup that should use the new wpg and choose Data Points->Move DPGs to Selected WPGs from the bcs menu. After this, the dataPoints of the selected dpGrp use the weightPositions of the new wPosGrp. This wpg can then be modified independently from wpg 1.

Weight Space

The weightSpace is an n-dimensional space, where n is the number of weights. In this space, each weight has its own axis. DataPoints are positioned anywhere in this space.

By giving weights values, you specify a point in this weightSpace. This is the current point. The dataPoints are weighted based on their position and the position of the current point. When the weights are set so that the defined point is exactly at a dataPoint’s position, we say that the dataPoint has been reached.

Weight Value

Each weight has a value. This is what you animate. Bilateral weights have two values: a left and a right. This means that bilateral weights can be animated differently on one side than on the other.

WPos Interpolation

There’s a correspondence between a weight’s value and the amount a wPos is active. In the simplest case, a weight has one wPos at position 1 with linear or spline interpolation. If the value of the weight is 0, the wPos is 0. If the weight is 1, the wPos is 1. Placing a dataPoint at this wPos creates a direct relationship between the weight’s value and the amount the dataPoint participates in the deformation (this is a plain dataPoint).

The different interpolations are:

• linear
  This interpolation makes the wPos correspond linearly to the weight’s value. If an inbetween wPos is interpolated linearly, the deformation is like with blendShape inbetweens: the object first deforms to the inbetween dataPoint and then deforms to the plain dataPoint. There will be a jerk in the middle of the movement.

• flat
  Unlike spline interpolation, flat results in no anticipation or overshoot. The movement will have no jerks but will not be very fluent either.

• precise
  This is a compromise between spline and flat. Here, the first and last wPos of a weight will fade like spline. An anticipation or overshoot is prevented by making the curves flat at crossovers from one wPos’ curve to the other.

• spline
  This interpolation results in very fluent movements. Depending on the other weightPositions of this weight there will be anticipation and/or overshoot.

• enhanced
  This is a slightly tweaked version of the spline interpolation. With three or more wps, it results in even more anticipation to preserve the behavior around the actual position.

• arc
  This interpolation was specifically designed for inbetween wps that need to make arced movements. It works best on one wPos that is on layer 1. The position at 1.0 should be spline or linear.

• inverse arc
  Use this interpolation for creating arcs around the zero position of a weight. It works best on layer 0 (main layer) positions at equal distance to the zero position, e.g. on -1 and 1.

• disabled
  This will disable the weightPosition. A dataPoint that uses it in its position cannot be reached, even when the weight values are set accordingly.

Note that precise, spline, and enhanced behave exactly as linear when the wPos is the only one of the weight (or when the other weightPositions can’t be seen because of their layers).

WPos Layer

A weightPosition has a layer of 0 by default. This is the main layer. Deeper layers (1, 2, 3, etc.) are called sub-layers. Only inbetween wps can be on sub-layers.

WPos Position

Each weightPosition belongs to a certain value of one weight. This value is called its position. It is not to be mixed up with dataPoint positions. The position of a wPos has to be unique in its weight (actually in its wPosGrp). This means that there can be only one wPos at a certain value of a weight.