Alex Forsythe

Key Points

• MotionBuilder's base class for scene objects is FBComponent. Everything you see in the navigator is a component.
• The scene consists of a bunch of components inside of graph data structure, represented by source and destination connections.
• Each component owns a number of FBProperty objects which are connected by way of ownership connections.
• FBPlug is the base class which defines connection functionality for both components and properties.
• Every component has a selection state, a unique name, and a list of properties.
• The Selected property allows us to tell whether a component is selected and to select or deselect a component.
• A full name takes the form groupname::namespace:name, and it must be unique within the scene. The group name is static and is based on the component's type.
• A long name (or label name) takes the form namespace:name, and it must be unique within the group.
• A name (or short name) is the rightmost part of the name, containing no colons, and it must be unique within the group and namespace.
• A group of "nested" namespaces is in fact a single, unique namespace that happens to contain a colon (e.g. a component named "aaa:bbb:ccc" has the namespace "aaa:bbb" and the short name "ccc").
• The LongName property allows long names to be read or changed, and ditto Name for short names. To modify namespaces en masse, we can use the ProcessNamespaceHierarchy method.
• Each component has an FBPropertyManager instance which contains all its properties. Properties can be obtained by name via PropertyList.Find().
• In Python, a property's Data attribute can be used to get or set its value.
• FBBox is a subclass of FBComponent that uses animation nodes to facilitate real-time evaluation of its properties.
• FBModel is a subclass of FBBox that exists in space within the scene. Cameras, lights, markers, cubes, nulls, etc. are models.
• Every model has a Translation, Rotation, and Scaling vector, which can be accessed or modified directly. The GetMatrix and SetMatrix methods provide access to a model's transformation matrix.
• Models are hierarchical. A model can have a Parent and zero or more Children. These relationships can be modified procedurally by setting the Parent property.

Code

print cube.Selected
cube.Selected = True
cube.Selected = False

cube.LongName = 'alpha:bravo:Cube'
print cube.LongName  # prints 'alpha:bravo:Cube'
print cube.Name      # prints 'Cube'
cube.Name = 'Kubus'
print cube.LongName  # prints 'alpha:bravo:Kubus'

cube.ProcessNamespaceHierarchy(
    FBNamespaceAction.kFBConcatNamespace, 'OLD')
cube.ProcessNamespaceHierarchy(
    FBNamespaceAction.kFBReplaceNamespace, 'OLD', 'NEW')

cube.PropertyList.Find('Show').Data = True
cube.Show = True # <-- equivalent

cube.Translation = FBVector3d(0.0, 5.0, 0.0)

m = FBMatrix(); cube.GetMatrix(m)
for i in (4, 5, 6):
    m[i] *= 2.0 # Double the Y-scale
m[13] += 5.0 # Move up along global Y by 5 units
cube.SetMatrix(m)

''' If parentModel were already childModel's Parent, setting it so would
instead UNparent it (for some reason). In lieu of this check, we could also
set childModel.Parent = None before proceeding. '''
if childModel.Parent != parentModel:
    childModel.Parent = parentModel

Notes & Errata

The Maya Analogy

Around 0:50, I make a comparison between MotionBuilder's components and Maya's nodes. This comparison is apt in that components and nodes are the most basic object type in their respective applications, but they're not exactly equivalent.

Most importantly, Maya's nodes implement functionality which in MotionBuilder is delegated to multiple classes, primarily FBBox in addition to FBComponent. Whereas Maya uses groups of multiple nodes to represent complex objects, MotionBuilder implements specialized object types by way of inheritance.

Source and Destination Connections

A similar caveat: At 0:54, when you see the depiction of the source and destination relationships that connect all the components in the scene, you may be reminded of Maya's Hypergraph editor, where the lines running between objects represent the lazily-evaluated flow of animation data for specific properties. This is not what source and destination connections do.

MotionBuilder has a very similar system for evaluating animation data in real-time, but it's done (roughly speaking) on a property-to-property basis rather than a component-to-component basis. As we'll get into later on, real-time evaluation of properties involves animation nodes which belong to FBBox objects. FBComponents themselves do not deal with animation.

Source and destination connections only describe relationships between components — they don't convey any data. MotionBuilder manages them transparently, and you should never need to worry about modifying them yourself.

Corrections?

If you see any errors that you'd like to point out, feel free to email me at awforsythe@gmail.com.