| public static ReflectMatrix ( Matrix &m ) : void | ||
| m | Matrix | The matrix to be reflected across the Z axis |
| return | void | |
// template FrameTransformMatrix
// {
// Matrix4x4 frameMatrix;
// }
/// <summary>
/// Imports a transform matrix attached to a ContentNode
/// </summary>
/// <returns>The transform matrix attached to the current ContentNode</returns>
private Matrix ImportFrameTransformMatrix()
{
Matrix m = tokens.SkipName().NextMatrix();
// Reflect the matrix across the Z axis to swap from left hand to right hand
// coordinate system
ContentUtil.ReflectMatrix(ref m);
// skip the "}" at the end of the node
tokens.SkipToken();
return(m);
}
// "This template is instantiated on a per-mesh basis. Within a mesh, a sequence of n
// instances of this template will appear, where n is the number of bones (X file frames)
// that influence the vertices in the mesh. Each instance of the template basically defines
// the influence of a particular bone on the mesh. There is a list of vertex indices, and a
// corresponding list of weights.
// template SkinWeights
// {
// STRING transformNodeName;
// DWORD nWeights;
// array DWORD vertexIndices[nWeights];
// array float weights[nWeights];
// Matrix4x4 matrixOffset;
// }
// - The name of the bone whose influence is being defined is transformNodeName,
// and nWeights is the number of vertices affected by this bone.
// - The vertices influenced by this bone are contained in vertexIndices, and the weights for
// each of the vertices influenced by this bone are contained in weights.
// - The matrix matrixOffset transforms the mesh vertices to the space of the bone. When concatenated
// to the bone's transform, this provides the world space coordinates of the mesh as affected by the bone."
// (http://msdn.microsoft.com/library/default.asp?url=/library/en-us/
// directx9_c/dx9_graphics_reference_x_file_format_templates.asp)
//
// Reads in a bone that contains skin weights. It then adds one bone weight
// to every vertex that is influenced by ths bone, which contains the name of the bone and the
// weight.
public void ImportSkinWeights()
{
isSkinned = true;
string boneName = tokens.SkipName().NextString();
// an influence is an index to a vertex that is affected by the current bone
int numInfluences = tokens.NextInt();
List <int> influences = new List <int>();
List <float> weights = new List <float>();
for (int i = 0; i < numInfluences; i++)
{
influences.Add(tokens.NextInt());
}
for (int i = 0; i < numInfluences; i++)
{
weights.Add(tokens.NextFloat());
if (weights[i] == 0)
{
influences[i] = -1;
}
}
influences.RemoveAll(delegate(int i) { return(i == -1); });
weights.RemoveAll(delegate(float f) { return(f == 0); });
while (tokens.Peek == ";")
{
tokens.NextToken();
}
// Add the matrix that transforms the vertices to the space of the bone.
// we will need this for skinned animation.
Matrix blendOffset = tokens.NextMatrix();
ContentUtil.ReflectMatrix(ref blendOffset);
skinTransformDictionary.Add(boneName, blendOffset);
SkinTransformContent trans = new SkinTransformContent();
trans.BoneName = boneName;
trans.Transform = blendOffset;
skinTransforms.Add(trans);
// end of skin weights
tokens.SkipToken();
// add a new name/weight pair to every vertex influenced by the bone
for (int i = 0; i < influences.Count; i++)
{
skinInfo[influences[i]].Add(new BoneWeight(boneName,
weights[i]));
}
}
/*
* template Animation
* {
* [...]
* }
*/
/// <summary>
/// Fills in all the channels of an animation. Each channel refers to
/// a single bone's role in the animation.
/// </summary>
/// <param name="boneName">The name of the bone associated with the channel</param>
/// <returns>The imported animation channel</returns>
private AnimationChannel ImportAnimationChannel(out string boneName)
{
AnimationChannel anim = new AnimationChannel();
// Store the frames in an array, which acts as an intermediate data set
// This will allow us to more easily provide support for non Matrix
// animation keys at a later time
AnimationKeyframe[] rotFrames = null;
AnimationKeyframe[] transFrames = null;
AnimationKeyframe[] scaleFrames = null;
List <AnimationKeyframe> matrixFrames = null;
boneName = null;
tokens.SkipName();
for (string next = tokens.NextToken(); next != "}"; next = tokens.NextToken())
{
// A set of animation keys
if (next == "AnimationKey")
{
// These keys can be rotation (0),scale(1),translation(2), or matrix(3 or 4) keys.
int keyType;
AnimationKeyframe[] frames = ImportAnimationKey(out keyType);
if (keyType == 0)
{
rotFrames = frames;
}
else if (keyType == 1)
{
scaleFrames = frames;
}
else if (keyType == 2)
{
transFrames = frames;
}
else
{
matrixFrames = new List <AnimationKeyframe>(frames);
}
}
// A possible bone name
else if (next == "{")
{
string token = tokens.NextToken();
if (tokens.NextToken() != "}")
{
tokens.SkipNode();
}
else
{
boneName = token;
}
}
}
// Fill in the channel with the frames
if (matrixFrames != null)
{
matrixFrames.Sort(new Comparison <AnimationKeyframe>(delegate(AnimationKeyframe one,
AnimationKeyframe two)
{
return(one.Time.CompareTo(two.Time));
}));
if (matrixFrames[0].Time != TimeSpan.Zero)
{
matrixFrames.Insert(0, new AnimationKeyframe(new TimeSpan(),
matrixFrames[0].Transform));
}
for (int i = 0; i < matrixFrames.Count; i++)
{
Matrix m = matrixFrames[i].Transform;
ContentUtil.ReflectMatrix(ref m);
matrixFrames[i].Transform = m;
anim.Add(matrixFrames[i]);
}
}
else
{
List <AnimationKeyframe> combinedFrames = ContentUtil.MergeKeyFrames(
scaleFrames, transFrames, rotFrames);
for (int i = 0; i < combinedFrames.Count; i++)
{
Matrix m = combinedFrames[i].Transform;
ContentUtil.ReflectMatrix(ref m);
combinedFrames[i].Transform = m; //* Matrix.CreateRotationX(MathHelper.PiOver2);
anim.Add(combinedFrames[i]);
}
}
return(anim);
}