天行健 君子当自强而不息

Building a Morphed Mesh through Manipulation

Directly manipulating a mesh's vertex buffers is probably the easiest way to work with morphing. For this method you'll need a third mesh that contains the final coordinates of each vertex after morphing; it's this third mesh that you'll render.

To create the third mesh, which I call the resulting morphed mesh, you can clone the source mesh and be on your way.

// Declare third mesh to use for resulting morphed mesh
ID3DXMesh *pResultMesh = NULL;

// Clone the mesh using the source mesh pSourceMesh
pSourceMesh−>CloneMeshFVF(0, pSourceMesh−>GetFVF(), pDevice,&pResultMesh);

After you've created the resulting morphed mesh (pResultMesh), you can begin processing the morphing animation by locking the source, target, and resulting morphed mesh's vertex buffers. Before you do that however, you need to declare a generic vertex structure that contains only the vertex coordinates, which you'll use to lock and access each vertex buffer.

typedef struct {
  D3DXVECTOR3 vecPos;
} sGenericVertex;

Also, because each vertex buffer contains vertices of varying sizes (for example, the source might use normals whereas the target doesn't), you need to calculate the size of the vertex structure used for each mesh's vertices. You can do so using the D3DXGetFVFVertexSize function.

// pSourceMesh = source mesh object
// pTargetMesh = target mesh object
// pResultMesh = resulting morphed mesh object
DWORD SourceSize = D3DXGetFVFVertexSize(pSourceMesh−>GetFVF());
DWORD TargetSize = D3DXGetFVFVertexSize(pTargetMesh−>GetFVF());
DWORD ResultSize = D3DXGetFVFVertexSize(pResultMesh−>GetFVF());

Now you can lock the vertex buffers and assign the pointers to them.

// Declare vertex pointers
char *pSourcePtr, *pTargetPtr, *pResultPtr;
pSourceMesh−>LockVertexBuffer (D3DLOCK_READONLY, (void**)&pSourcePtr);
pTargetMesh−>LockVertexBuffer (D3DLOCK_READONLY, (void**)&pTargetPtr);
pResultMesh−>LockVertexBuffer (0, (void**)&pResultPtr);

Notice how I assigned a few char * pointers to the vertex buffers instead of using the generic vertex structure? You need to do that because the vertices in the buffers could be of any size, remember? Whenever you need to access a vertex, you cast the pointer to the generic vertex structure and access the data. To go to the next vertex in the list, add the size of the vertex structure to the pointer. Get it? If not, don't worry−the upcoming code will help you make sense of it all.

After you've locked the buffers you can begin iterating through all vertices, grabbing the coordinates and using the calculations from the previous section to calculate the morphed vertex positions. Assuming that the length of the animation is stored in Length and the current time you are using is stored in Time, the following code will illustrate how to perform the calculations:

// Length = FLOAT with length of animation in milliseconds
// Time = FLOAT with time in animation to use
// Calculate a scalar value to use for calculations
float Scalar = Time / Length;

// Loop through all vertices
for(DWORD i=0;i<pSourceMesh−>GetNumVertices();i++) 
{
	// Cast vertex buffer pointers to a generic vertex structure
	sGenericVertex *pSourceVertex = (sGenericVertex*)pSourcePtr;
	sGenericVertex *pTargetVertex = (sGenericVertex*)pTargetPtr;
	sGenericVertex *pResultVertex = (sGenericVertex*)pResultPtr;

	// Get source coordinates and scale them
	D3DXVECTOR3 vecSource = pSourceVertex−>vecPos;
	vecSource *= (1.0f − Scalar);

	// Get target coordinates and scale them
	D3DXVECTOR3 vecTarget = pTargetVertex−>vecPos;
	vecTarget *= Scalar;

	// Store summed coordinates in resulting morphed mesh
	pResultVertex−>vecPos = vecSource + vecTarget;

	// Go to next vertices in each buffer and continue loop
	pSourcePtr += SourceSize;
	pTargetPtr += TargetSize;
	pResultPtr += ResultSize;
}

Up to this point I've skipped over the topic of vertex normals because normals are identical to vertex coordinates in that you use scalar and inversed scalar values on the normals to perform the same calculations as you do for the vertex coordinates.

In the preceding code, you can calculate the morphing normal values by first seeing whether the mesh uses normals. If so, during the loop of all vertices you grab the normals from both the source and target vertices, multiply by the scalar and inversed scalar, and store the results. Take another look at the code to see how to do that:

// Length = FLOAT with length of animation in milliseconds
// Time = FLOAT with time in animation to use
// Calculate a scalar value to use for calculations
float Scalar = Time / Length;

// Set a flag if using normals
BOOL UseNormals = FALSE;

if(pSourceMesh−>GetFVF() & D3DFVF_NORMAL && pTargetMesh−>GetFVF() & D3DFVF_NORMAL)
	UseNormals = TRUE;

// Loop through all vertices
for(DWORD i=0;i<pSourceMesh−>GetNumVertices();i++) 
{
	// Cast vertex buffer pointers to a generic vertex structure
	sGenericVertex *pSourceVertex = (sGenericVertex*)pSourcePtr;
	sGenericVertex *pTargetVertex = (sGenericVertex*)pTargetPtr;
	sGenericVertex *pResultVertex = (sGenericVertex*)pResultPtr;

	// Get source coordinates and scale them
	D3DXVECTOR3 vecSource = pSourceVertex−>vecPos;
	vecSource *= (1.0f − Scalar);

	// Get target coordinates and scale them
	D3DXVECTOR3 vecTarget = pTargetVertex−>vecPos;
	vecTarget *= Scalar;

	// Store summed coordinates in resulting morphed mesh
	pResultVertex−>vecPos = vecSource + vecTarget;

	// Process normals if flagged
	if(UseNormals == TRUE) 
	{
		// Adjust generic vertex structure pointers to access
		// normals, which are next vector after coordinates.
		pSourceVertex++; pTargetVertex++; pResultVertex++;

		// Get normals and apply scalar and inversed scalar values
		D3DXVECTOR3 vecSource = pSourceVertex−>vecPos;
		vecSource *= (1.0f − Scalar);

		D3DXVECTOR3 vecTarget = pTargetVertex−>vecPos;
		vecTarget *= Scalar;

		pResultVertex−>vecPos = vecSource + vecTarget;
	}

	// Go to next vertices in each buffer and continue loop
	pSourcePtr += SourceSize;
	pTargetPtr += TargetSize;
	pResultPtr += ResultSize;
}

Everything looks great! All you need to do now is unlock the vertex buffers and render the resulting mesh! I'll skip the code to unlock the buffers and get right to the good part−rendering the meshes.

Drawing Morphed Meshes

If you're building the morphing meshes by directly manipulating the resulting mesh's vertex buffer, as shown in the previous section, then rendering the morphing mesh is the same as for any other ID3DXMesh object you've been using. For example, you can loop through each material in the mesh, set the material and texture, and then draw the currently iterated subset. No need to show any code here−it's just simple mesh rendering.

On the other hand, if you want to move past the basics and start playing with real power, you can create your own vertex shader to render the morphing meshes for you. Take my word for it−this is something you'll definitely want to do. Using a vertex shader means you have one less mesh to deal with because the resulting mesh object is no longer needed; the speed increase is well worth a little extra effort.

Before you can move on to using a vertex shader, however, you need to figure out how to render the mesh's subsets yourself.

Dissecting the Subsets

To draw the morphing mesh, you need to set the source mesh's vertex stream as well as the target mesh's stream. Also, you need to set only the source mesh's indices. At that point, it's only a matter of scanning through every subset and rendering the polygons related to each subset.

Wait a second! How do you render the subsets yourself? By duplicating what the ID3DXMesh::DrawSubset function does, that's how! The DrawSubset function works in one of two ways. The first method, which you use if your mesh has not been optimized to use an attribute table, is to scan the entire list of attributes and render those batches of polygons belonging to the same subset. This method
can be a little slow because it renders multimaterial meshes in small batches of polygons.

The second method, which is used after you optimize the mesh to use an attribute table, works by scanning the built attribute table to determine which grouped faces are drawn all in one shot. That is, all faces that belong to the same subset are grouped together beforehand and rendered in one call to DrawPrimitive or DrawIndexedPrimitive. That seems like the way to go!

To use the second method of rendering, you need to first optimize your source mesh. You can (and should) do this when you load the mesh. It's a safe habit to optimize all meshes you load using the ID3DXMesh::OptimizeInPlace function, as shown in the following bit of code:

// pMesh = just−loaded mesh
pMesh−>OptimizeInPlace(D3DXMESHOPT_ATTRSORT, NULL, NULL, NULL, NULL);

Once the mesh is optimized, you can query the ID3DXMesh object for the attribute table it is using. The attribute table is of the data type D3DXATTRIBUTERANGE, which is defined as follows:

typedef struct_D3DXATTRIBUTERANGE {
  DWORD AttribId;
  DWORD FaceStart;
  DWORD FaceCount;
  DWORD VertexStart;
  DWORD VertexCount;
} D3DXATTRIBUTERANGE;

The first variable, AttribId is the subset number that the structure represents. For each material in your mesh, you have one D3DXATTRIBUTERANGE structure with the AttribId set to match the subset number.

Next come FaceStart and FaceCount. You use these two variables to determine which polygon faces belong to the subset. Here's where the optimization comes in handy−all faces belonging to the same subset are grouped together in the index buffer. FaceStart represents the first face in the index buffer belonging to the subset, whereas FaceCount represents the number of polygon faces to render using that subset.

Last, you see VertexStart and VertexCount, which, much like FaceStart and FaceCount, determine which vertices are used during the call to render the polygons. VertexStart represents the first vertex in the vertex buffer to use for a subset, and VertexCount represents the number of vertices you can render in one call. When you optimize a mesh based on vertices, you'll notice that all vertices are packed in
the buffer to reduce the number of vertices used in a call to render a subset.

For each subset in your mesh you must have a matching D3DXATTRIBUTERANGE structure. Therefore, a mesh using three materials will have three attribute structures. After you've optimized a mesh (using ID3DXMesh::OptimizeInPlace ), you can get the attribute table by first querying the mesh object for the number of attribute structures using the ID3DXMesh::GetAttributeTable function, as shown
here:

// Get the number of attributes in the table
DWORD NumAttributes;
pMesh−>GetAttributeTable(NULL, &NumAttributes);

At this point, you only need to allocate a number of D3DXATTRIBUTERANGE objects and call the GetAttributeTable function again, this time supplying a pointer to your array of attribute objects.

// Allocate memory for the attribute table and query for the table data
D3DXATTRIBUTERANGE *pAttributes;
pAttributes = new D3DXATTRIBUTERANGE[NumAttributes];
pMesh−>GetAttributeTable(pAttributes, NumAttributes);

Cool! After you've got the attribute data, you can pretty much render the subsets by scanning through each attribute table object and using the specified data in each in a call to DrawIndexedPrimitive. In fact, do that now by first grabbing the mesh's vertex buffer and index buffer pointers.

// Get the vertex buffer interface
IDirect3DVertexBuffer9 *pVB;
pMesh−>GetVertexBuffer(&pVB);

// Get the index buffer interface
IDirect3DIndexBuffer9 *pIB;
pMesh−>GetIndexBuffer(&pIB);

Now that you have both buffer pointers, go ahead and set up your streams, vertex shader, and vertex element declaration, and loop through each subset, setting the texture and then rendering the polygons.

// Set the vertex shader and declaration
pDevice−>SetFVF(NULL); // Clear FVF usage
pDevice−>SetVertexShader(pShader);
pDevice−>SetVertexDeclaration(pDecl);

// Set the streams
pDevice−>SetStreamSource(0, pVB, 0, pMesh−>GetNumBytesPerVertex());
pDevice−>SetIndices(pIB);

// Go through each subset
for(DWORD i=0;i<NumAttributes;i++) 
{
	// Get the material id#
	DWORD MatID = pAttributes[i];

	// Set the texture of the subset
	pDevice−>SetTexture(0, pTexture[AttribID]);

	// Render the polygons using the table
	pDevice−>DrawIndexedPrimitive(D3DPT_TRIANGLELIST, 0, 
			pAttributes[i].VertexStart, 
			pAttributes[i].VertexCount, 
			pAttributes[i].FaceStart * 3, 
			pAttributes[i].FaceCount);
}

After you've rendered the subsets you can free the vertex buffer and index buffer interfaces you obtained.

pVB−>Release(); pVB = NULL;
pIB−>Release(); pIB = NULL;

When you're done with the attribute table, make sure to free that memory as well.

delete [] pAttributes; pAttributes = NULL;

All right, now you're getting somewhere! Now that you know how to render the subsets yourself, it's time to move on to using a vertex shader.

Check Out the Demos

This project demonstrates building morphing meshes by directly manipulating a mesh's vertex buffer.

Figure 8.4: The animated dolphin jumps over morphing sea waves!

WinMain.cpp:

download source file