Absolute Data Point

When the pure mix 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.

For more information see Relative and Absolute DataPoints.

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.


Note that the mode of the edit geometry overrides the mode of the dataPoint. That means that a relative dataPoint with absolute geometry behaves like an absolute dataPoint.




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 main (bilateral) version. What you model is the main (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.


After tweaking one side, the changes can be mirrored to the other.

Bilateral Weight

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

For more information see 5.7 The Automatic Left-Right Separation.

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 Data Point

A Combination dataPoint is a dataPoint that has a position containing more than one weightPosition.

This means a combination dataPoint is connected to more than one weight. The result is that it is only added to the deformation when the respective weights are all non-zero.

For more information please refer to 5.2 Weights and DataPoints.


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.

For more information see Chapter 4. The BCS Philosophy and Chapter 5. How the System Works.

Corrective Deltas

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

Data Point (DP)

DataPoints are the central objects in the BCS and contain all the deformation data controllable by the weights. They consist of a position in weight space and delta vectors defining the deformation the dataPoint represents.

They are explained in detail in 5.2 Weights and DataPoints.

Data Point Group (DPG)

All dataPoints that use weightPositions of the same weights are grouped together in what is 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 together 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. A dataPoint with the positions 1.0*0.5 is listed after a dataPoint with the position 0.5*1.0.

Advanced Info

To avoid self-influencing dataPoints, all dataPoints of one dataPointGroup have to use weightPositions of the same wPosGrps.

Data Point Mode

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

More information can be found in Relative and Absolute DataPoints.

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 weight space. The position consists of one or more weightPositions (all from different weights, of course).

Advanced Info

A special case is the empty (parking) position. This is the only position at which more than one dataPoint can be. These dataPoints never affect the system, but they’re stored in the node and can be positioned at a later time.


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 not-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.

Advanced Info

The input shape is usually a shape node under the same transform as the displayed shape. It can’t be seen because its intermediateObject attribute is set to true.


The prefix DPK is used to ensure all node, command and MEL procedure names are unique and do not collide with other scripts and plugins. It stands for Daniel Pook-Kolb.

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 Blend Shape 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 like 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 pure mix when it is reached. This will be of little use in many cases.


Note that the mode of the edit geometry overrides the mode of the dataPoint. That means that a relative dataPoint with absolute geometry behaves like an absolute dataPoint.

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 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, it is highly recommended to take a look and study the FACS Manual. Their web site can be found here:

See also FACS in Chapter 4. The BCS Philosophy.


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.

For more information see 5.7 The Automatic Left-Right Separation.

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 called 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.

For more information on inbetweens see 5.3 Inbetween Basics: WeightPositions.

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).


Don’t change this input geometry while Freeze Input is on. See the description of the Freeze Input settings.

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 is not. In this case, you can specify a falloff that will be used to create the unilateral sub-dataPoints of the instance.


A dataPoint that is a combination of n weights can only be an instance of a dataPoint that has less than n weights in its position! This prevents dependency cycles to occur.

Plain Data Point

A dataPoint with a plain position is a plain dataPoint. It has a direct connection to its weight and embodies the main motion the weight creates. It behaves just like a Blend Shape target.

If the wPos that constitutes its position has certain interpolation settings or isn’t the only one on the main layer, the connection between the dataPoint and the weight is not linear. In this case, the behavior is not exactly as a Blend Shape target.

See also 5.2 Weights and DataPoints.

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).

Pure Mix

Every dataPoint has a pure mix. It is the deformation that would be the result when the position of the dataPoint is reached with the dataPoint itself being absent.

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

Advanced Info

The pure mix of a dataPoint is its absolute minus its relative deltas. Or the other way round: when you add the relative data of a dataPoint to its pure mix, you get the absolute data of the dataPoint.

Relative Data Point

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

For more information see Relative and Absolute DataPoints.

Relative Geometry

Relative geometry displays a dataPoint’s relative data. This is the correction that is added to the pure mix 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.


Note that the mode of the edit geometry overrides the mode of the dataPoint. That means that an absolute dataPoint with relative geometry behaves like a relative dataPoint.

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.

See also 5.7 The Automatic Left-Right Separation.

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.


View geometry can become very useful when editing a plain dataPoint that affects one or more relative combination dataPoints. You can see the appearance of the different combinations and how they change while you model the plain dataPoint. With absolute edit geometry, the combination dataPoints would behave like absolute dataPoints and couldn’t inherit the changes at all.

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


Weights are the animatable attributes that represent the interface between the animator and the node and thus control the whole deformation.

Each weight has one (for simple) or two (for bilateral) values. With these values, you define the current position in the weight space. This position is then used together with the positions of all the dataPoints to calculate how much each dataPoint affects the deformation.

For more information see 5.2 Weights and DataPoints and the following sections.

Weight Position (wPos or WP)

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

Each WP has a position, a layer and an interpolation.

For more information see 5.3 Inbetween Basics: WeightPositions.

Weight Position Group (wPosGrp or 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.

For more information see 5.6 WeightPositionGroups.

Weight Space

The weight space is an n-dimensional real vector space spanned by the n weights, so each weight has its own axis. DataPoints are positioned anywhere in this space, except at the origin at 0.

By giving weights values, you specify a point in this weight space. This is the current point. Animating the weight attributes creates a curve in the weight space. This curve is smooth if all animation curves are smooth, i.e. have no sharp corners like when using linear interpolation. 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.

See also 5.2 Weights and DataPoints.

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.

For more information see 5.7 The Automatic Left-Right Separation.

WPos Interpolation

There is 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).

For general information see 5.5 WeightPosition Interpolations.

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 Blend Shape inbetweens: the object first deforms to the inbetween dataPoint and then deforms to the plain dataPoint. There will be an abrupt change in the direction of the motion in the middle of the movement.

  • flat
    Unlike spline interpolation, flat results in no anticipation or overshoot. The motion will be smooth but it will not look very fluent in most cases.

  • 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 motion. 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 motions. 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. Higher layers (1, 2, 3, etc.) are called sub-layers. Only inbetween WPs can be on sub-layers.

For more information see 5.4 WeightPosition 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, or more precisely, in its wPosGrp. This means that in a wPosGrp there can be only one wPos at a certain value of a weight.

For more information see 5.3 Inbetween Basics: WeightPositions.