Character Animation with Direct3D- P9 pptx

In the next example I create a rigid body for the Oriented Bounding Box OBB class that was covered in the previous chapter.. So, each frame the rigid body is updated using the Bullet phy

//Create Rigid Body btRigidBody *body = new btRigidBody(mass, ms, cs, localInertia);

//Add the new body to the dynamics world pDynamicsWorld->addRigidBody(body);

Then to run the simulation all you need to do is call the stepSimulation()

function each frame, like this:

pDynamicsWorld->stepSimulation(deltaTime);

That’s it! The rigid body you have now created will be simulated each frame, colliding with other rigid bodies, etc However, you still won’t see anything on the screen because the box is nothing but a logical representation You need to hook up the current motion state of the rigid body to a mesh In the next example I create

a rigid body for the Oriented Bounding Box (OBB) class that was covered in the previous chapter So, each frame the rigid body is updated using the Bullet physics library and then rendered using DirectX like this:

void OBB::Render() {

//Get Motion state from rigid body btMotionState *ms = m_pBody->getMotionState();

if(ms == NULL)return;

//Convert the motion state to a DX matrix //and use it to set the world transform pEffect->SetMatrix("matW", &BT2DX_MATRIX(*ms));

//Render the mesh as usual using whichever lighting technique D3DXHANDLE hTech = pEffect->GetTechniqueByName("Lighting");

pEffect->SetTechnique(hTech);

pEffect->Begin(NULL, NULL);

pEffect->BeginPass(0);

m_pMesh->DrawSubset(0);

pEffect->EndPass();

pEffect->End();

}

You’ll find the source code for the first example using the Bullet physics engine

in Example 7.1

After that little detour of getting to know the Bullet physics library, it is time to get back to what I was trying to achieve in this chapter: ragdoll animation! You need to choose some of the major bones of the character and create a physical representation for them that can be simulated in the physics engine Then as the ragdoll is simulated, the position and orientation are updated for the bones using the transforms taken from the rigid bodies, before rendering the mesh Sounds easy? Well, not quite It takes a lot of effort to make ragdoll animation look good and free from artifacts You should also note that not all bones in the character are simulated (such as finger bones and other small bones) Figure 7.6 shows a picture of a character and its ragdoll setup

EXAMPLE 7.1

This example integrates the Bullet physics engine into a Direct3D applica-tion In this example, 100 boxes of different sizes are dropped from the “sky” and collide with the ground plane and with each other Try to expand this example to include shapes other than just boxes—for example, cylinders and spheres (there are corresponding functions in DirectX to create sphere and cylinder meshes).

You don’t necessarily have to use boxes as in Figure 7.6 You can also use cylin-ders, capsules, or any other shape you see fit Later on I will cover in more detail how

to position the shapes to match the skeleton However, should you run the simulation after just placing boxes, they would all fall to the floor, disjointed from each other You need some form of “connection” between the under arm and the upper arm, for example This is where constraints come into the picture A constraint is just what it sounds like; it is a rule telling two rigid bodies how they can move in relation to each other The two simplest forms of constraints are shown in Figure 7.7

FIGURE 7.6

An example ragdoll setup.

FIGURE 7.7

The ball and hinge joints.

Bullet supports the following constraints:

Point-to-point constraint (a.k.a ball joint) Hinge constraint

Twist cone constraint

6 degrees of freedom (DoF) constraint The ball joint doesn’t have any restrictions on angle or twist amount, whereas the hinge joint allows no twisting of the connected rigid bodies The twist cone is a mix between the ball and hinge joints With the twist cone constraint, you can specify the angle range and twist amount allowed (which is very useful when creating a ragdoll) With the 6DoF constraint, you can specify exactly the angle ranges of each DoF This

is a bit more functionality than you need to implement a simple ragdoll animation, but check out the Bullet SDK for more information on these constraints

Here’s how you would create a simple constraint with the Bullet physics engine Let’s assume you have two rigid bodies (Aand B) created as shown in the previous example You would create a hinge constraint between them like this:

//Set transforms and axis for the hinge (for each rigid body) btTransform localA, localB;

localA.setIdentity();

localB.setIdentity();

localA.getBasis().setEulerZYX(0,0,0);

localA.setOrigin(btVector3(0.0f, -0.5f, 0.0f));

localB.getBasis().setEulerZYX(0,0,0);

localB.setOrigin(btVector3(0.0f, 0.5f, 0.0f));

//Create Hinge Constraint btHingeConstraint *hingeC;

hingeC = new btHingeConstraint(A, B, localA, localB);

hingeC->setLimit(-0.5f, 0.5f);

//Add the constraint to the dynamics world pDynamicsWorld->addConstraint(hingeC, true);

That’s how simple it is to add a constraint between two rigid bodies The con-straint limit specifies how much the hinge can bend back and forth Example 7.2 shows you how this is done with the twist cone and ball joint constraints

CONSTRUCTING THE RAGDOLL

Now that you know how to connect physical rigid bodies using constraints, the next step of creating a ragdoll is not far off…in theory All you have to do is to create a series of boxes (or other shapes) connected via different constraints However, in practice it is slightly more difficult than that First you need to make sure that the boxes match the skeleton (and the character mesh) as close to perfect as possible Otherwise you would get weird results updating the bone hierarchy of the character using an ill-fitting physical representation So the problem you are about to face is the one shown in Figure 7.8

EXAMPLE 7.2

This example implements some of the most common constraints available

to you in the Bullet library A large number of boxes are created, connected into a long “string.” Run the simulation many times and observe the difference between the hinge, the point, and the twist-cone constraints Also, play around with the limits of the constraints and see the effect it gives Be sure to study how the con-straints are created, since you’ll need a good understanding of this in the next section where a ragdoll is created.

In Figure 7.8 you see a part of a character—namely, an arm For a working ragdoll animation you must create a physical representation of the character that you can simulate in your physics engine At each frame you update the skeleton of

the character to match the physical representation and, voila!, You’ve got yourself a

ragdoll For the purpose of creating, updating, simulating, and rendering a ragdoll, I’ve created the following class with the somewhat unimaginative name RagDoll:

class RagDoll : public SkinnedMesh {

public:

RagDoll(char fileName[], D3DXMATRIX &world);

~RagDoll();

void InitBones(Bone *bone);

void Release();

void Update(float deltaTime);

FIGURE 7.8

Solid character arm mesh (top) Arm wireframe and bones (middle) Arm wireframe and physical representation (bottom).

void Render();

void UpdateSkeleton(Bone* bone);

OBB* CreateBoneBox(Bone* parent, Bone *bone,

D3DXVECTOR3 size, D3DXQUATERNION rot);

void CreateHinge(Bone* parent, OBB* A, OBB* B,

float upperLimit, float lowerLimit, D3DXVECTOR3 hingeAxisA, D3DXVECTOR3 hingeAxisB, bool ignoreCollisions=true);

void CreateTwistCone(BONE* parent, OBB* A, OBB* B,

float limit, D3DXVECTOR3 hingeAxisA, D3DXVECTOR3 hingeAxisB,

bool ignoreCollisions=true);

private:

vector<OBB*> m_boxes; //Boxes for physics simulation };

I’ll cover the more technical functions and creation of this class throughout the coming sections But first there are some challenges you’ll face when approaching this problem For example, how do you place the Oriented Bounding Boxes so that they fit the mesh as closely as possible? You could, of course, attempt an algorithmic approach This might be best if you need to create physical representations for a large number of characters, or if your characters are generated or randomized in some way In that case you should probably traverse through the bones and deter-mine which ones are big enough to merit a physical representation (remember, small bones like fingers are ignored) Next you would have to find the vertices linked

to this bone and, for example, use Principal Component Analysis (PCA) to fit an Oriented Bounding Box to the bone and its vertices [VanVerth04] This is outside the scope of this book, however, so I’ll stick with the old-fashioned way of doing things: “by hand.”

Even the “by hand” approach will need some supporting calculations to place the Oriented Bounding Box as optimally as possible See Figure 7.9

With the “by hand” fitting scheme I will only supply the size of the Oriented Bounding Box and use the orientation of the bone itself Having the size and the orientation, you only need to calculate the position of the OBB before you can place it in the world Figure 7.9 shows a simplified 2D image of a character’s arm

If you need to place the upper arm bounding box, you just take the two end points (points A and B) of the upper arm bone and place the bounding box at the middle point of these two end points The following piece of code comes from the Ragdoll class and does just this:

struct Bone: public D3DXFRAME {

D3DXMATRIX CombinedTransformationMatrix;

OBB *m_pObb;

};

OBB* RagDoll::CreateBoneBox(Bone* parent, Bone *bone,

D3DXVECTOR3 size, D3DXQUATERNION rot) {

if(bone == NULL || parent == NULL) return NULL;

//Get bone starting point D3DXMATRIX &parentMat = parent->CombinedTransformationMatrix; D3DXVECTOR3 parentPos(parentMat(3, 0),

parentMat(3, 1), parentMat(3, 2));

//Get bone end point D3DXMATRIX &boneMat = bone->CombinedTransformationMatrix;

D3DXVECTOR3 bonePos(boneMat(3, 0), boneMat(3, 1), boneMat(3, 2));

FIGURE 7.9

Fitting an OBB to a bone.

//Extract the rotation from the bone D3DXQUATERNION q;

D3DXVECTOR3 p, s;

D3DXMatrixDecompose(&s, &q, &p, &parentMat);

//Offset rotation (in some cases only)

q *= rot;

D3DXQuaternionNormalize(&q, &q);

//Calculate the middle point

p = (parentPos + bonePos) * 0.5f;

//Create new OBB OBB *obb = new OBB(p, size, q, true);

//Add the OBB to the physics engine physicsEngine.GetWorld()->addRigidBody(obb->m_pBody);

//Add OBB to the ragdoll’s own list m_boxes.push_back(obb);

//Connect the bone to the OBB parent->m_pObb = obb;

return obb;

}

As you can see, I’ve added a pointer to an OBB in the Bonestructure Each bone now has a pointer to an Oriented Bounding Box Through this pointer the bone can retrieve the current position and orientation of the physical representation as the simulation runs Other than this, the OBB is created and placed as explained earlier Creating the Oriented Bounding Boxes is, of course, only the first step If you run the physics simulation now, you would see the boxes fall to the floor disjointed from each other Next you’ll need to connect them in a proper manner before you have a ragdoll This is the real tricky part and the hardest part to get right (i.e., to produce good-looking results) As covered earlier in Example 7.2, I’ll use the hinge and twist cone constraints to hold the boxes in place Take another look at Figure 7.9 When you place the constraints you will now place them in between the boxes instead, in the points A, B, and C The following function in the Ragdoll class creates a twist cone constraint between two Oriented Bounding Boxes (a similar function exists to create a hinge constraint):

void RagDoll::CreateTwistCone(Bone* parent, OBB* A, OBB* B,

float limit, D3DXVECTOR3 hingeAxisA, D3DXVECTOR3 hingeAxisB, bool ignoreCollisions) {

if(parent == NULL || A == NULL || B == NULL) return;

//Extract the constraint position D3DXMATRIX &parentMat = parent->CombinedTransformationMatrix; btVector3 hingePos(parentMat(3, 0),

parentMat(3, 1), parentMat(3, 2));

D3DXVECTOR3 hingePosDX(parentMat(3, 0),

parentMat(3, 1), parentMat(3, 2));

//Get references to the two rigid bodies you want to connect btRigidBody *a = A->m_pBody;

btRigidBody *b = B->m_pBody;

//Get world matrix from the two rigid bodies btTransform aTrans, bTrans;

a->getMotionState()->getWorldTransform(aTrans);

b->getMotionState()->getWorldTransform(bTrans);

D3DXMATRIX worldA = BT2DX_MATRIX(aTrans);

D3DXMATRIX worldB = BT2DX_MATRIX(bTrans);

//Calculate pivot point for both rigid bodies D3DXVECTOR3 offA, offB;

D3DXMatrixInverse(&worldA, NULL, &worldA);

D3DXMatrixInverse(&worldB, NULL, &worldB);

D3DXVec3TransformCoord(&offA, &hingePosDX, &worldA);

D3DXVec3TransformCoord(&offB, &hingePosDX, &worldB);

btVector3 offsetA(offA.x, offA.y, offA.z);

btVector3 offsetB(offB.x, offB.y, offB.z);

//Set constraint axis aTrans.setIdentity();

bTrans.setIdentity();

aTrans.setOrigin(offsetA);

bTrans.setOrigin(offsetB);

aTrans.getBasis().setEulerZYX(

hingeAxisA.x, hingeAxisA.y, hingeAxisA.z);

hingeAxisB.x, hingeAxisB.y, hingeAxisB.z);

//Create new twist cone constraint btConeTwistConstraint *twistC;

twistC = new btConeTwistConstraint(*a, *b, aTrans, bTrans);

//Set Constraint limits twistC->setLimit(limit, limit, 0.05f);

//Add constraint to the physics engine physicsEngine.GetWorld()->addConstraint(twistC, true);

}

This function is generally pretty straightforward The only tricky thing in here

is to calculate the pivot point for the two rigid bodies Since the pivot point needs

to be in the local space of the rigid body, you have to multiply the world-space location of the pivot point with the inverse of the rigid body’s world matrix Next

I set the constraint axes and limits, and finally the constraint is added to the physics simulation There’s now only one final thing left to do, and that is to make use of these two functions and create the ragdoll The following is an excerpt from the constructor of the RagDollclass:

RagDoll::RagDoll(char fileName[], D3DXMATRIX &world) : SkinnedMesh() {

//Load the character from an x file SkinnedMesh::Load(fileName);

//Set beginning pose SetPose(world);

//Find bones to use in the construction of the ragdoll //

Bone* U_R_Arm=(Bone*)D3DXFrameFind(m_pRootBone,"Upper_Arm_Right"); Bone* L_R_Arm=(Bone*)D3DXFrameFind(m_pRootBone,"Lower_Arm_Right"); Bone* R_Hand=(Bone*)D3DXFrameFind(m_pRootBone, "Hand_Right"); //

D3DXQUATERNION q;

D3DXQuaternionIdentity(&q);

//Right arm (two bounding boxes) OBB* o03 = CreateBoneBox(U_R_Arm, L_R_Arm,

D3DXVECTOR3(0.3f, 0.12f, 0.12f), q); OBB* o04 = CreateBoneBox(L_R_Arm, R_Hand,

D3DXVECTOR3(0.3f, 0.12f, 0.12f), q); //

//Constraints //

CreateTwistCone(U_R_Arm, o08, o03, D3DX_PI * 0.6f,

D3DXVECTOR3(0.0f, D3DX_PI * 0.75f, 0.0f), D3DXVECTOR3(0.0f, 0.0f, 0.0f));

CreateHinge(L_R_Arm, o03, o04, 0.0f, -2.0f,

D3DXVECTOR3(0.0f, 0.0f, D3DX_PI * 0.5f), D3DXVECTOR3(0.0f, 0.0f, D3DX_PI * 0.5f));

}

To keep this code excerpt from taking up too many pages, I show only how the arm of the ragdoll is set up You’ll find the complete initialization of the ragdoll in the next example However, as you can see, the character is first loaded as a skinned mesh from an x file Next I set the pose I want to use as the bind pose for the character while creating the ragdoll Then I use the CreateBoneBox(), CreateTwistCone(), and

CreateHinge()functions to create the full physical representation of the character As always, you’ll find the full code for the ragdoll setup in Example 7.3