From BlenderWiki

[edit] Tutorial Part 2 of 2

So far, we have imported a MoCap cloud, made a constrained armature (skeleton) that respects and follows that cloud movement. We now will make a clone that operates independently of the cloud. We have to extract usable portions of that animation into our library. One of the first issues is scale and orientation; in your library you generally want all generic actions performed by an armature facing the same way. That way, as you flip through them they are instantly recognizable, and it is easier to fit/adapt into your scene. then we have to isolate quality actions for later use. This section presents a process for doing all of that, and then follows up with a practical example.

[edit] Focus on Area of Interest

The motion capture file can consist of thousands of frames and hundreds of markers. On lesser PCs, this could create quite a performance drag. We therefore want to reduce that as much as possible before baking, and certainly only want discrete actions in our library for easy reference and integration. Using the Play-Climb-Jump file as an example, we see a few motions that might be re-usuable:

• the landing 1300-1420 (after cleaning a few markers)
• a duck under action in frames 1420-1660
• the cleaned "duck under" action in frames 1730-1970
• landing (iteration 2) frames 2500-2660 (clean RFHD discontinuity)

The rest of the session is just more of the same, and this area provides two samples of two motions. No one ever does the same action the same way twice, which is why I point out the two landings, and the two duck under actions. You will want to have multiple versions of the same thing, so that if you are in the situation where you need to cycle, or iterate, an action, you have a few different ones to string together. Viewers are quick to pick up when a motion is the same as one used recently, and in fact, even if the same motion is used at different times in a short, the audience can tell.

[edit] Bake Your Bones

In the Blender Scripts Catalog, in the Animation Section, locate the Bake_Constraints.py script discussed earlier. I wrote this script to accomplish the baking needed for this critical step for turning bones controlled by markers following IPO curves into Actions. For example, recall that the example cloud was 80 BU high. If you try to scale the armature down now, the head and feet will still try to point to those empties that are so far away, and it won't work right. What we need is a way to remove that dependency between the armature and those empties, so that the armature can move about on its own. The method to do this step is called "baking". When you bake a cake, you mix a bunch of ingredients together, pop it in the oven in a slurry form, and out comes something firm. Baking in animation is the same way. Right now, there are lots of "ingredients" (markers and constraints) being used to drive this armature. After baking, we want each bone to be able to move by itself, using its own Ipo curve that is location and orientation independent.

Once you have downloaded this script and placed it in your scripts directory, you can run it from the menu or manually as described above and in the wiki User Manual for saving and running scripts. To download and/or find out more about the Animation Bake Constraints script, read this. This script is part of the standard distribution with 2.47, and is in the Scripts menu, Animation section as "Bake Constraints".

Briefly, you:

1. . Load your cleaned, constrained armature file (BVH or C3D)
2. . Set your animation range to the focus area of interest (for example, frames 1300-1420)
3. . Select the Constrained Armature in Object Mode
4. . Run the Bake Constraints script. While it is baking, the oven light may go off (your Blender Screen may go black). Don't be alarmed, just watch the console window for progress and updates. Blender is just concentrating on running the script as fast as possible.
5. . The script clones the Armature, removes all the constraints on the clone (making it a free man)
6. . The script then creates an Action that copies the original motion, offset to begin at frame 1.
7. . You can now delete the cloud, ik targets, and constrained armature to free up memory

The Action contains LocRot Ipo curves for each bone for each frame of the animation, so it can take some time to process. The action is named after the clone; you can immediately change this to better reflect what the clone is doing by clicking in the Action Editor header, in the name field of the Action selector (the name will get a red background), and typing in the new name. The Action keys are relative to the T-pose of the character, sometimes called the rest or edit position. This is the orientation that the armature assumes when you tab into edit mode.

The clone should follow the original around,

• offset in space (by the location-rotation vector usrDelta, by default set to (10,10,0)) and
• offset in time by usrACTION (if True, the clone will start the action at frame 1, otherwise it will start the action simultaneous with the cloud).

The clone should perform the same motion as the original. No bones should have "hinge" enabled (see Pose mode, Armature Bones panel), because the baked keys have both location and rotation already computed.

This clone should move and gesture just like the original. The difference is that you no longer need the empties or their Ipo curves for this motion. In our example Play-Climb-Jump MoCap session, we would set our frame range to a narrow focus area, NOT 1-3400. Trying to bake all three thousand frames would take forever and consume a lot of memory and result in a huge file. Once that Landing action is baked, proceed as described to put that action into your library. For this example file, I recommend baking the following actions:

• Landing: from 1300-1430 (after cleaning a few markers)
• Landing.001: from rames 2500-2660 (clean RFHD discontinuity)
• Duck-Under: frames 1420-1660
• Duck-Under.001: frames 1730-1970

When making or storing copies of the same basic thing, Blender has the convention of adding a three digit sequence number to the end of the name, and I have kept that in naming similar actions. You can adopt your own conventions, such as "Landing-1". Alternatively, you can have one action, "Landing", but have the different cycles in that action, just at different frame ranges, for example, frames 1-130 for cycle 1, and 150-280 for cycle 2. Either way, you will be able to access these action equally easy using Blender's NLA later on.

You can run another bake cycle to bake the other four actions, saving them in this same file, if you wish. Refer to the following discussion on Atomicity and how to save multiple actions into the same file:

• Select the constrained armature
• Set your animation range
• Bake the Action
• Reset the Action to start at Frame 1, Name it, and Fake User it
• Kill the Clone

While it may seem heartless to kill the clones, the script will create a clone each time you bake, and you may safely delete them since you are only interested in the Action - just be sure that the Fake User button is enabled so that the action is saved, even though no armature object uses it. Note also that when you give the second landing action the name "Landing", Blender will rename it to "Landing.001" to uniquely identify that cycle from the original.

	NLA can Override Actions:
	If an NLA sequence has been assigned to the original armature for some reason, the clone will inherit this NLA, and will not automatically play the Action just baked, unless you add it as an Action Strip to the NLA.

[edit] Clean Up Your Act

So, we now have the clone performing the same action as the cloud, but at a different time, in fact, at a standardized time, namely starting at frame 1. When starting a library, it is very important that all library elements follow some sort of standard, so that they can be consistently and easily identified and used by a team, possibly years later. This section describes some of the activities you should do to clean up and standardize this action.

[edit] Atomicity and File Naming

You have your choice of two approaches in building your action library, and each can be used interchangeably. The simplest is to have one atomic action in one file. Right now, the baked Action is linked to the Object. If you import (re-use) that Object into another file, the Action will come with it. When you save this file, the action is saved in the file. If you de-link the Action (press the X next to the name in the Action Editor header) but keep the Fake User enabled (the F button next to the X), the Action will be saved in the .blend file. In our example, you would name the file "Play-Climb-Landing" to denote its contents.

However, and this is important, an Object can have many possible Actions saved in the file (but only one can be linked at any one time). You will then be able to create other Actions for this Armature and save those Actions in the same .blend file, so long as their Fake User button is enabled. The motion capture session we are using as an example has four areas of interest; two landings and two duck-unders. If we were to save one file with those four actions, we have a file naming problem. If we call it "Play-Climb-Landing" we lose the identification (at the file level) that the file also contains a duck-under action. We could call it simply "Play-Climb-Combo", but that is not very descriptive. I personally hate having to sift through generically-named library files, opening them only to see that they do not have what I want. In this case, I would name the file "Play-Climb-Landing-and-Duck-Under". Later, as I collect more and more actions in the Play-Climb series, then I would make an all-inclusive "Play-Climb" library file containing all the actions associated with climbing around on a jungle gym in a playground area.

In this example we identified four actions of interest. Since they all come from the same C3D file, it makes sense to save all of them in the same .blend file. Alternatively, you could create two files; one called Play-Climb-Landing containing the two Landing actions, and another called Play-Climb-Duck-Under containing the two duck-under actions.

[edit] Initial T-Pose

Probably the initial pose to get your library started is the T-Pose. You can select any of the automatically built armatures,

• enter Pose mode
• de-link whatever action is being performed by clicking the X in the Action Editor window header,
• select all bones in the armature A
• select Pose->Clear Transform->Clear Rotation or press Alt R.

Upon confirmation, Blender will arrange the skeleton into a T-pose like that shown to the right by rotating all the bones to (0,0,0). This pose is used in skinning your character, namely applying a mesh to the Armature, so that you can render your character performing the action. The whole purpose of an armature is to do this.

Key this T-pose (or any pose) by

• Ensure that no action is linked to the Armature (a blank Action Editor)
• Select all bones in Pose mode, press I and select Rot for Rotation.
• Select the root bone, press I, and select Rot.
• In the Action Editor window header, name the AC: "T-Pose"
• Save the file

You can now call in this object and T-Pose action to have your standard skeleton for skinning and further rigging. What's nice about this skeleton is that it is taken from actual human references, so all the proportions are correct.

[edit] Using Actions with Different Armatures

Each action identifies the bone to be moved by its name, shown as the channel name in the Action Editor. So long has your armature has an edit position similar to the T-Pose, and names the same as these bones, the MoCap action will animate your armature. There may be issues with different bone lengths, as the the relative location of the bone has an Ipo curve, but further research on this topic is required.

[edit] Single User Armature

The Clone and the contrained Original both use the same Armature. If you want to display the clone using Stick, or make any strcutural (edit) changes to the clone, you will have to make a Single User copy. To do this, in the Buttons Window, select the Object context. In the Links and Material panel (where the Pose Library is shown), you will see two fields: AR: and OB:. The AR: field, which says that this object is an Armature type, will have a number button to the left of the Fake User button. This number shows how many objects are using this Armature. Click it, and Blender will confirm you want to make a copy.

[edit] Reset the Action Start

By setting usrACTION=False in the Bake Constraints script, you can compare the two actions and ensure the script performed correctly because they will execute at the same time (frame range). The clone (drawn using the Stick display) and the original (drawn using the Octahdron display) both move together. In the image to the right, we have made a single user copy of the clone and changed it to bone display, and have moved its action to start at 1 (I set usrACTION=True)

If usrACTION=False, after verifying that you have baked the correct frames for the action, you will want to reset the action to start occurring at frame 1. You do not want actions in your library starting at odd times. Select the bone clone, and change your Ipo Window to an Action Editor. The keys for each of the bones should be displayed, in the range baked (in our example, range 1300-2620). You first want to move all the keys for all the bone to start at frame 1. You might want to expand the window to full screen (ctrl-up arrow or shift-control-space). Scroll the window up so that all bones are displayed. Press A to select all the keys, and Grab them and drag them to the right, holding the ctrl key down to get even frame numbers. Repeat until you have the display shown to the right, with all keys for all bones starting at frame 1.

Re-set your animation start and end frame to (1,120). Since you saved your cleaned file with the complete motion capture as "pose-climb-jump CMU xx_xx.blend", you can delete all the empties and the original armature from this session.

[edit] Rename the Action

The action (by default) is named after the clone. If you did not do so before, you should now change this to better reflect what the clone is doing by clicking in the Action Editor header, in the name field of the Action selector (the name will get a red background), and typing in the new name. Good naming is important:

• Rename the Action to "Landing" as in "to stick the landing".
• Rename the Scene to "Landing"
• Rename the Armature to "Human"
• Rename the Object to "Justin" (or whatever the subject's name was reported as - see original Armature)
• Save the file as "play-climb-landing.blend" in your library. As noted previously, I keep my library of poses in a Blender/lib/pose folder.

[edit] Delete Object Location Ipo Curve

If you examine Object Ipo for the baked clone, if you selected the option to create one during Baking, you will see that there is an Ipo on the Object itself, which (usually) stays at origin. When you use this action in a scene, however, you will almost certainly want to place and orient the armature in a different place. Therefore, you can simply de-link the curve from the object by clicking the X next to the Ipo Name in the Ipo Window header. Now you can locate and rotate the armature any way you want. For example, in Top view, press R to rotate the skeleton 180 degrees. If you pre-vis now, you will see that he ducks or jumps or performs the action facing a different way.

Re-save the library action file. The de-linked object Ipo curve will not be saved, since it does not have any users.

[edit] Make it to Scale

There are two ways to scale the resulting MoCap. The first way was when the cloud was imported, there was a scale factor contained in the file. Manually altering this value will produce a different sized cloud. However, this method has not been fully explored and there might be issues with skating feet. The recommended way is to scale the clone and use a stride bone to avoid skating.

Let's continue our example, the extract of the Play-Climb-Jump file, frames 2500-2xxx, where he jumps down and lands. We baked that motion in the previous step. Select the Clone armature, then Select->Inverse, and X delete it. You should be left with the unconstrained clone. Verify that the clone still does the action. If it just stands there or collapses into a heap of rubble, you deleted the wrong armature!

With the armature selected, scale it down to about 2 BU size by:

1. . Press N to display the properties panel. Note the Scale is 1.0
2. . Press S and move your mouse toward the armature. As you move, the armature shrinks and the Scale in the property panel decreases.
3. . When the Scale reaches about 0.125 and the DimZ value reaches 2,  LMB click.

Notice that the object location of the armature object was at (0,0,0). If you used rotation/scaling about object center, as you scaled the armature, it shrank, just like in the movie "Honey I Shrank The Kids". Because the bones are all located relative to one bone, and all motion was relative to the center, as its legs got shorter, the distance to center also got proportionally smaller as well. Therefore, everything stayed relative. Now when you pre-vis, you should not see any skating or walking in a hurricane. All action happens normally, just on a smaller scale.

[edit] Identify Key Poses

The goal of this process is to extract primitive (atomic) actions that can then be blended, sped, cycled and repeated. We also want to remove action keys for bones that should not be moving. Using our MoCap capture session of two people shaking hands, a primitive action is the following actions:

• approach (24-90) (24 Rory's legs cross over, watch the XY motion of the root bone)
• clasp and pump (91-)
• hold (161-) (notice how Justin starts backing away)
• release (221-) (almost reluctantly, Rory lets go)

By breaking down the overall MoCap action into its constituent parts, we can see where good cross over or transition points are, and use these parts as building blocks into desired animations. For example, if we wanted a longer handshake with more pumps, we could cycle/iterate just the pump action. If we wanted a quick handshake, we could change the timing of the action by scaling that action shorter so that the same motion occurs over shorter range. If we bound that by the clasp and release, we now have our desired action. If we want to blend in some animation done by hand, we can simply delete the keys for those bones and replace them with our own keys.

[edit] Make a Pose Library

In Blender, these key points in the action can be saved as poses in a [Pose Library]. The pose libraries for an Armature is found in its Links and Materials panel, and is connected to the Armature. As long as an Object (Justin, or Rory) use the Armature (Human), the poses associated with it will be available to them. Each Motion Capture session Focus Area has at least a start and an end pose, and it is handy to "bookmark" these poses so you can quickly jump between them when integrating and matching poses from action to action.

Taking our Play-Climb-Landing example, make these key poses available later, add these three Poses to the Pose Library:

• frame 1: Landing-Tuck
• frame 80: Landing-Stretch
• frame 160: Landing-end

You can then apply any pose to an armature at any time just by selecting them. You then key that pose at any frame by selecting all bones and pressing I, which creates a key in the active Action. This way, you can create new pose-to-pose actions by re-using existing poses.

Just to confuse you, I will also say that other armatures, like an Armature designed to look or fit like a Troll, can also use a Pose Library, simply by selecting the Armature, and then choosing the Pose Library from the Pose Library: AC: selector. This Troll could then use the "walk-even" library of poses. You choose the pose for that armature by selecting the pose from the gray-brown selector beneath it. As long as the Armature has the same bone names, those bones will be moved into location relative from their T-pose position.

[edit] Keyed versus Pose-to-Pose Animation

The Bake Constraints script creates a key for every bone for every frame. This keyframing captures every subtlety and nuance in the movement. Human realistic motion is full of mis-steps, corrections, staggers, over-corrections and such that make for some jittery motion. You may or may not want that. If you are making a comic, you only really want the key poses in your Library.

If you want your library to use Pose-to-Pose animation, use the Action editor and select only the keys for the Poses in your pose Library (use the Box select to select the keys for all bones for a frame), and delete the remaining keys (you can Select->Inverse Keys). Since the keys are connected by an Ipo Curve, Blender will smoothly transition the armature from Pose to Pose.

[edit] Combine Actions

Here we will construct a new scene by re-using two actions from our library, and transitioning them together. I build on the example files I have discussed, specifically:

• Play-Climb-Landing, imported and cleaned
• Team-Hand-Shake

In this scene, we want our Superman character, who has bee busy saving the Space Shuttle, to land and shake hands with the President. We will be using Blender's Non-Linear Animation editor to combine these action from our pose (action) library to combine and blend those two actions.

I assume you have processed the two files above using our workflow thus far:

• Locate and download the C3D files
• Import the C3D file and inspect the constrained rig
• Select a frame range to focus on
• Clean any discontinuity and jitter
• Bake the constrained rig
• Delete everything from the file except the clone (to save space)
• Remove the clone's Object location and rotation curves
• Rename scenes and the clone; add comments to a text file as appropriate
• Save the file in your library using a taxonomy

[edit] Initial Armature and Action

Starting with a new Blender session, add a ground plane, and anything else you want to use as a set and props, such as a podium on a stage. Set the camera level, as if the scene was being televised by a film crew, facing the stage/podium straight on (use any announcement video or campaign speech video as a reference).

From the User Preferences (main) header, select {{Literal|File->Append or Link

• Navigate to your library folder
• Delve into the Play-Climb-Landing file
• Delve into Objects
• Select Justin
• Click Append (into Active Layer and At Cursor are good things to enable)

This workflow brings in the object and its armature, and any linked Actions. By convention, I leave the predominant action in the file linked to the Object, so that when I append, I get at least one action - in this case, "Landing".

If you do not have the Object and the Action linked when you save the library file, then now you will have to Append again, but this time delve into Action, not Object, and select the Action named "Landing".

[edit] Append Other Actions

Navigate into the other library files and extract the actions you want. Shift RMB to select multiple actions. In our example, delve into the Team-Hand-Shake library and get Handshake-Justin and Handshake-Rory. Review each of the actions and Fake User them if you want to keep them.

Before leaving this step, ensure that neither Armature Object has any Action linked to it. If you collapse the menu on the Action Editor header, you should not see the name of any of the actions; just the selector button. If you flip up the list of Actions, you should see them all there with an F beside them, waiting to be used.

In our example, we delve into the team-hand-shake file, and pull in the Justin:hand-shake and Rory:hand-shake (we will need someone for our superhero to shake hands with!)

[edit] Create a Custom Pose and Action

We need our SuperHero to fly in, crouch, land and shake hands. We have the crouch to land part, and the land to shake hands part, but not the fly to crouch pose transition. I guess Superman wasn't available for motion capture. Lets make that pose and transition now.

The end of this Action, called Fly2Land, is that crouched position that starts off the Landing. In the 3D View, select the Armature Justin. In the Action Editor, link in the Action "Landing" (or Landing.001 if you used that one). Reset your timeline to Frame 1, and select ADD NEW from the Action selector. "Wait" you say "nothing happened?" Well yes, it did. You just made a copy of the active Action when you did the ADD NEW. Rename this Action Fly2Land, and verify that you now have four actions. We now need to edit this Action.

First, delete all the keys for all the bones for frames 2 through the end. This is simple enough; simply un-select all the keys (the diamonds will be white), and box select the ones from frames 2 onward, and press X in the window (not the X in the Header). I like to switch to full screen mode for this operation, because there is a lot of data to delete. The alternative is to select frame 1, then Select->Inverse Keys, and then press X.

Grab the keys from frame 1 and move them to 30. This is now the ending pose, and the transition will take about a second. Reset your animation back to frame 1, and re-pose SuperJustin to be in a flying position. Start by rotating and moving the root bone, and keying its LocRot. Then work through all the bones, rotating them into place, and keying their Rot. I set my 3D cursor in the middle of his chest to give me a point of reference, because I imagined that, if I was superman, as I came in for a landing, I would pull my arms back and gather my feet under me, and that means I would pretty much rotate around my torso. Without changing frames, key the bones by:

• Select all bones in pose mode in the 3D View A
• Key the bone rotations I -> Rot
• Select the root bone
• Key its Location I->Loc

Test the transition by cycling through the animation. Any bones that did not change rotation, like the toes or hands, will be connected by a yellow band. Save your work in a neat sounding file, like "Superman Lands". De-link your armature from this Action, leaving him in the flying pose.

Notice that, in 3D space, Superman does not move. The object center is still at (0,0,0). Also, all the action starts at frame 1! This idea is a little hard to get used to, I must admit. As it flies in the face of traditional animation using objects.

	Orgainic Flow:
	There are no straight lines in organic forms. When posing your character, even though you want him to look "streamlined" to not flatten him out like a board, or he will look stiff and unrealistic.

[edit] Block in the President's Action

Import Rory, or duplicate Justin, so we have the other actor, let's call him "President" (change the name in the OB: field). Let's start with him, since he only has one action: that of shaking Superman's hand. In the Action Editor, link him to the Rory:hand-shake action and review. We want the handshake to be "center stage" so adjust the location of President to about (-85,0,0). He should enter frame left (in Front view), and the handshake should occur at about X=0. You may want to select the right hand in Pose mode to see it clearer. De-link the Action from the Armature, because we will be linking it using the NLA.

Blender features the Non-Linear Animation tool for this purpose. In this window, we bring in each Action, and place it in the time-line when we want our character to perform that action. Achieve the example to the right,

• Select the President in the 3D View
• In the NLA Window, Strip->Add Action and pick the Royr:hand-shake action
• Either Grab and move the strip so it starts at frame 200, or use the strip's properties panel N to set the start and end to 300 and 501. Notice that the Action Start and End is locked to 1 and 301.

Now in our scene, the President will "stand by" off-camera from frames 1-200, and then will execute the hand-shake action from scene frame 200-501 by performing the Rory:hand-shake action frames 1-301. As you can see, this is the way to you get an actor to perform an action (or piece of an action) when you want him to.

[edit] Arrange Superman's Actions

Superman gets three strips:

1. Fly-Land (or Fly2Land), a 30-frame strip that starts at scene frame 1
2. Landing, which starts at scene frame 21, but action starts at frame 10 (cutting 9 frames of roll-up)
3. Justin:hand-shake, which starts at scene frame 141 and ends at 441

As shown to the left, for each strip, we enable auto-blending so that there is a smooth transition from one action to the next. the Landing strip is selected (yellow) and the properties panel shows you the settnigs to make. I unlocked the Action Start in order to cut out that 9-frame roll-up).

We then have to adjust his position to (17,-51,0) so that his handshake (at scene frame 330) matches up with the President's hand).

	X marks the spot:
	In stage plays, you put white tape in the shape of an X to mark where you want an actor to be. You might want to place a cube or plane at origin (0,0,0) so that you have a point of reference in 3D top view

[edit] Blend the Actions

Now we see that Superman needs to either do something for two seconds, or the handshake needs to start at frame 141, not 200 as originally blocked in with the President. To keep in simple, adjust the President's hand-shake strip to start at 141 and end at 442, to match up with Superman's coordinated action.

In the transition from landing to hand-shake, the root bone was located in one place during the landing MoCap session, and was located in a different place at the start of the hand-shake MoCap baking. However, in our blended scene, we want a smooth motion and transition of his body from the end of one to the start of the next. We can do this by moving the object linearly so that, from frame to frame, the root bone moves relatively smoothly. This Ipo curve is shown to right; between frames 151 and 181, Superman as an object needs to slide about 25 units in the X direction; as Blender blends the two strips, this object location transition will counter-act any undesired root bone movement.

We also need Superman's fly-in and tuck transition to be a little more convincing. At frame one, key Superman at (80,-51,80), and at frame 81 key location (26,-51,0) to make him drop as he un-tucks. In the original MoCap, the actor was necessarily hanging onto a bar as he un-tucked into the stretch position; this fixed-hand location does not make sense for Superman flying through the air. Animating his location thus moves his hands and makes a more convincing animation.

We have just constructed a 440-frame sequence by combining manual animation actions with motion-capture sequences to construct a shot. The armatures can be easily skinned and rendered for a game cut-shot or for a movie. Since the motion-capture sequences were taken directly from real people performing the actions, they are action-realistic, authentic, and therefore convincing. Discounting the up-front cost of importing and baking these actions, as that cost is amortized over the life-time of the library (20 years?), the time needed to construct the scene is reduced dramatically to simply time spent searching the library and orienting the armature object (creating an Ipo LocRot curve keys) for that scene-frame range.

[edit] Conclusion

Advances in workflow and productivity are driven by a creative process that uses and demands better tools, which in turn drives changes and improvements in process and workflow. This paper provides a framework for this cycle of improvement as it relates to Character Animation and Blender by examining a way to integrate Motion Capture into the Animator's workbench. As we have seen, there are vast libraries of motion capture data to draw on, containing hundreds of actions, both common, ordinary, every day actions like walking and cleaning, and extraordinary actions like karate and fighting. The Blender community, notably Campbell Barton, Jean-Louis Perin, and myself have coded software that imports that data into Blender from the two most common formats, BVH and C3D. This paper provides a method for using C3D files, importing, cleaning and isolating reusable components (actions) and saving them in a Blender library. This paper then provides an example or re-using and blending those actions into a new scene by combining manual animation and recorded animation actions into a composite scene.

Re-using actions derived from motion capture data can be useful either:

• directly in driving an armature, or
• indirectly in simply studying real motion.

Real human motion is full of sway, twists, mis-calculations, recovery, and other imperfections that make it "human". Studying and using these motions in a common medium (the Skeleton, or an applied mesh) is a useful way to learn how to mimic human motion. If a CG scene is to include humanistic motion, using motion capture actions can save thousands of hours of labor and speed up time to market for a game or movie, resulting in lower cost by hundreds of thousands of dollars, better quality, and faster production.

For further information or suggestions, please contact the author of this paper, rogerwickes (at) yahoo.com.