Character Animation with Direct3D- P20 potx

Next, the points returned from the control hairs are blended depending on the 2D position of the hair vertex.. As said before, the beauty of going the long way about this is that you now

Trang 1

//Get position from the four control hairs float3 ch1 = GetHairPos(0, IN.hairIndices[0],

IN.hairIndices[1], IN.position.z);

float3 ch2 = GetHairPos(1, IN.hairIndices[0],

//Blend linearly in 2D float3 px1 = ch2 * IN.position.x + ch1 * (1.0f - IN.position.x); float3 px2 = ch3 * IN.position.x + ch4 * (1.0f - IN.position.x);

float3 pos = px2 * IN.position.y + px1 * (1.0f - IN.position.y);

//Transform to world coordinates float4 posWorld = mul(float4(pos.xyz, 1), matW);

OUT.position = mul(posWorld, matVP);

//Copy texture coordinates OUT.tex0 = IN.tex0;

return OUT;

}

Here, the exact same operations are done as described earlier in the GetBlended-Point()function of the HairPatch class The blended position of each of the four control hairs is obtained from the ControlHairTableusing the GetHairPos()helper function Note that the indices passed to the helper function have been pre-computed and stored in the vertex data Next, the points returned from the control hairs are blended depending on the 2D position of the hair vertex The resulting point will be

in object space, so to get it to the correct position on the screen it is multiplied with the world and the view-projection matrix As said before, the beauty of going the long way about this is that you now can update the control hairs on the CPU and the mesh

in the hair patch will just follow suit “automagically.”

Trang 2

CREATING A HAIRCUT

So how would you go about creating these 10 to 20 control hairs needed to create

a decent-looking haircut for a character? Well, the most obvious way is to enter them manually as was done with the four control hairs in Example 15.1 Although

it doesn’t take many minutes to realize that to model a set of 3D lines with a text editor is probably not the way to go The best way is to use 3D modeling software (Max, Maya, or whatever other flavor you prefer) Figure 15.7 shows an image of

a “haircut” created in 3D Studio Max as a set of lines

EXAMPLE 15.1

In Example 15.1 a single hair patch is created and rendered The four control hairs are animated with a simple noise function, and the mesh is updated and animated completely on the GPU.

Trang 3

I was lucky enough to know Sami Vanhatalo (Senior Technical Artist at Remedy Entertainment) who was kind enough to write an exporter for 3D Studio Max for

me With this exporter it becomes very easy to dump a set of lines from 3D Studio Max to either a text or a binary file I won’t cover the exporter here in this book since

it is written in Max Script and is out of the scope of this book However, you’ll find both the text and binary version of the exporter on the accompanying CD-ROM, along with detailed instructions on how to use them For the next example I’ll use the data that has been outputted from the binary exporter The data is in Table 15.1

FIGURE 15.7

Control hairs used to create a haircut.

Trang 4

TABLE 15.1 THE BINARY HAIR FORMAT

The file structure is very simple and doesn’t contain any superfluous information Feel free to modify the exporter according to your own needs In any case, to read a set of lines from a binary file with this format, I’ve created the LoadHair()function to the Hairclass The following code segment is an excerpt from this function showing how to read one of these haircut data files:

ifstream in(hairFile, ios::binary);

if(!in.good()) return;

//Version number long version;

in.read((char*)&version, sizeof(long));

//Number splines long numSplines = 0;

in.read((char*)&numSplines, sizeof(long));

long Number of points for Line 1 float X value Line 1, Point 1 float Y value Line 1, Point 1 float Z value Line 1, Point 1 float X value Line 1, Point 2 float Y value Line 1, Point 2 float Z value Line 1, Point 2

… float X value Line N, Point 1 float Y value Line N, Point 1 float Z value Line N, Point 1

Trang 5

//Read splines for(int i=0; i<numSplines; i++) {

ControlHair* ch = new ControlHair();

//Read points long numPoints = 0;

in.read((char*)&numPoints, sizeof(long));

for(int p=0; p<numPoints; p++) {

D3DXVECTOR3 point;

in.read((char*)&point, sizeof(D3DXVECTOR3));

ch->AddPoint(point);

}

m_controlHairs.push_back(ch);

}

in.close();

This “pipeline” is extremely simple and doesn’t have anything more than the bare essentials However, already with something simple as as this it becomes a breeze to create and edit “spline haircuts” and export to your game

ANIMATING THE CONTROL HAIRS

With all the work in the previous sections, you’ve accomplished one important thing: You’ve managed to greatly reduce the amount of splines or points that you need to animate Even though you would use a very lightweight physics system to update the individual hair strips, it would, in all likelihood, still be too heavy for a real-time application Now you can do your hair simulation on the control hairs only and in this way save a lot of effort Next comes the final problem, which is how

to animate the control hairs in a somewhat realistic and good-looking way In Chapter 6 you had a look at creating a simple physics engine with particles and springs Well, you don’t need much more than that to create a simplified physics simulation for your control hairs At each point of the control hair I’ll place a simple bounding sphere that I will test against a set of spheres defining the shape of the character head (you could also perform collision checks between the control hair spheres, but the end result doesn’t really justify the extra amount of collision checks required) Figure 15.8 shows the setup of our simple physics simulation:

Trang 6

I’ve created a very simple bounding sphere class to be used for the character head representation The BoundingSphereclass is defined as follows:

class BoundingSphere {

public:

BoundingSphere(D3DXVECTOR3 pos, float radius);

void Render();

bool ResolveCollision(D3DXVECTOR3 &hairPos, float hairRadius);

private:

static ID3DXMesh* sm_pSphereMesh;

D3DXVECTOR3 m_position;

float m_radius;

};

Not so surprisingly, this class contains a position and a radius used to define the bounding sphere The static sm_pSphereMeshand the Render()function is just for debugging and visualization purposes The most important function in this class is the ResolveCollision()function This function tests whether a point collides with the bounding sphere, and, if so, it moves the point away from the sphere until the point no longer touches the sphere:

FIGURE 15.8

Physical setup of the hair animation.

Trang 7

bool BoundingSphere::ResolveCollision(D3DXVECTOR3 &hairPos,

float hairRadius) {

//Difference between control hair point and sphere center D3DXVECTOR3 diff = hairPos - m_position;

//Distance between points float dist = D3DXVec3Length(&diff);

if(dist < (m_radius + hairRadius)) {

//Collision has occurred; move hair away from bounding sphere D3DXVec3Normalize(&diff, &diff);

hairPos = m_position + diff * (m_radius + hairRadius);

return true;

}

return false;

}

Once you have this function up and running and a few spheres placed to roughly represent the character head, you can start simulating in some fashion To get a hair animation to look good, there’s a whole lot of black magic needed For instance, you can’t use gravity in the same way you would for other physical simulations If you used only gravity for simulating the hairs, the result would end up looking like a drenched cat with hair hanging straight down In reality, haircuts tend to roughly stay

in their original shape To quickly emulate this, I’ve stored the original points of the control hair points as the haircut is created Then, at run time, I have a small spring force between the current control hair’s position and its original position This will keep the haircut from deforming completely To show a quick hair simulation in action, I’ve added the UpdateSimulation()function to the ControlHairclass:

void ControlHair::UpdateSimulation(

float deltaTime, vector<BoundingSphere> &headSpheres) {

const float SPRING_STRENGTH = 10.0f;

const D3DXVECTOR3 WIND(-0.2f, 0.0f, 0.0f);

for(int i=1; i<(int)m_points.size(); i++) {

//Point’s percentage along the hair float prc = i / (float)(m_points.size() - 1);

Trang 8

D3DXVECTOR3 diff = m_originalPoints[i] - m_points[i];

float length = D3DXVec3Length(&diff);

D3DXVec3Normalize(&diff, &diff);

//Update velocity of hair control point (random wind) float random = rand()%1000 / 1000.0f;

D3DXVECTOR3 springForce = diff * length * SPRING_STRENGTH; D3DXVECTOR3 windForce = WIND * prc * random;

m_velocities[i] += (springForce + windForce) * deltaTime;

//Update position m_points[i] += m_velocities[i] * deltaTime;

//Resolve head collisions for(int h=0; h<(int)headSpheres.size(); h++) {

if(headSpheres[h].ResolveCollision(m_points[i], 0.01f)) {

m_velocities[i] *= 0.5f;

} } } }

In this function, each point along the control hairs is updated with a random wind force as well as a spring force toward its original location This function also performs the collision checks between the character head representation (i.e., the head bounding spheres), making sure that the hair doesn’t go through the face and thus break the illusion

THE HAIR CLASS

Finally, to clean up all I’ve gone through in this chapter, I’ll tie together all the classes To do this I encapsulate all the control hairs and hair patches in a single class called Hair This class is responsible for loading hair binary files, creating all the patches from the loaded control hairs, managing the hair simulation, and finally rendering the haircut This class will also contain the hair texture used and the physical representation of the character head:

Trang 9

class Hair {

public:

Hair();

~Hair();

void LoadHair(const char* hairFile);

void CreatePatch(int index1,

int index2, int index3, int index4);

void Update(float deltaTime);

void Render(D3DXVECTOR3 &camPos);

int GetNumVertices();

int GetNumFaces();

public:

vector<ControlHair*> m_controlHairs;

vector<HairPatch*> m_hairPatches;

IDirect3DTexture9* m_pHairTexture;

vector<BoundingSphere> m_headSpheres;

};

One important thing to mention is that the Render()function in this class sorts all the hair patches in Z depth from the camera before rendering them to the screen The Update()function takes care of calling the UpdateSimulation()function in the

ControlHairobjects, providing the m_headSpheresvector for the physical simulation

If you want to extend this example, it would probably be in the Hairclass that you would, for example, keep a pointer to the head bone of the character Using this bone pointer you would then update the position of all the control hairs as the head moves around

Trang 10

EXAMPLE 15.2

In this example a complete haircut is created and simulated in real time You can control the angle of the camera by clicking and dragging the mouse By pressing space, you will see the physical representation of the head along with the control hairs as they are animated.

Trang 11

Figure 15.9 shows a series of frames taken from the animated hair.

CONCLUSIONS

After reading this chapter, you should have a good understanding of the difficulties you’re faced with when trying to implement hair animation To increase the quality

of the hair animation presented in this chapter, there are two obvious improve-ments First, create a proper physical simulation instead of the “random wind” force I’ve used here Second, attach the hair to the character head bone and let it inherit motion from the head of the character When doing this you’ll see some wonderful secondary motion as the character moves and then suddenly stops, etc

FIGURE 15.9

A haircut animated with the system covered in this chapter.

Trang 12

Another thing I haven’t covered in this chapter is the rendering of hair There are many advanced models of how light scatters on a hair surface A really great next stop for you is the thesis titled “Real-Time Hair Simulation and Visualization for Games” by Henrik Halen [Halen07] You can find this thesis online using the following URL:

http://graphics.cs.lth.se/theses/projects/hair/

In the next and final chapter of this book, I’ll put most of the concepts covered throughout this book into a single character class

CHAPTER 15 EXERCISES

Create a Hairclass supporting multiple levels of details Scale the number of segments used in hair strips and the number of hair strips used in total Try to create a longer haircut (This may require a more detailed physical representation of the character.)

Attach the haircut to a moving character head

Implement a triangle hair patch relying on three control hairs instead of four

Định dạng
Số trang	20
Dung lượng	648,58 KB