private void DrawMeshContainer(MeshContainerDerived mesh, FrameDerived frame, Device device)
{
if (mesh.SkinInformation != null)
{
int attribldPrev = -1;
for (int iattrib = 0; iattrib < mesh.numberAttributes; iattrib++)
{
int numBlend = 0;
BoneCombination[] bones = mesh.bones;
for (int i = 0; i < mesh.numberInfluences; i++)
{
if (bones[iattrib].BoneId[i] != -1)
{
numBlend = i;
}
}
if (device.DeviceCaps.MaxVertexBlendMatrices >= numBlend + 1)
{
Matrix[] offsetMatrices = mesh.offsetMatrices;
FrameDerived[] frameMatrices = mesh.frameMatrices;
for (int i = 0; i < mesh.numberInfluences; i++)
{
int matrixlndex = bones[iattrib].BoneId[i];
if (matrixlndex != -1)
{
Matrix tempMatrix = offsetMatrices[matrixlndex] *
frameMatrices[matrixlndex].combinedTransformationMatrix;
device.Transform.SetWorldMatrixByIndex(i, tempMatrix);
}
}
device.RenderState.VertexBlend = (VertexBlend)numBlend;
if ((attribldPrev != bones[iattrib].AttributeId) ||
(attribldPrev == -1))
{
device.Material = mesh.GetMaterials()[
bones[iattrib].AttributeId].Material3D;
device.SetTexture(0, mesh.meshTextures[
bones[iattrib].AttributeId]);
attribldPrev = bones[iattrib].AttributeId;
}
mesh.MeshData.Mesh.DrawSubset(iattrib);
}
}
}
else
{
device.Transform.World = frame.combinedTransformationMatrix;
ExtendedMaterial[] mtrl = mesh.GetMaterials();
for (int iMaterial = 0; iMaterial < mtrl.Length; iMaterial++)
{
device.Material = mtrl[iMaterial].Material3D;
device.SetTexture(0, mesh.meshTextures[iMaterial]);
mesh.MeshData.Mesh.DrawSubset(iMaterial);
}
}
}
public override MeshContainer CreateMeshContainer(string name, MeshData meshData, ExtendedMaterial[] materials, EffectInstance[] effectInstances, GraphicsStream adjacency, SkinInformation skinInfo)
{
if (meshData.Mesh == null)
{
throw new ArgumentException();
}
if (meshData.Mesh.VertexFormat == VertexFormats.None)
{
throw new ArgumentException();
}
MeshContainerDerived mesh = new MeshContainerDerived();
mesh.Name = name;
int numFaces = meshData.Mesh.NumberFaces;
Device dev = meshData.Mesh.Device;
if ((meshData.Mesh.VertexFormat & VertexFormats.Normal) == 0)
{
Mesh tempMesh = meshData.Mesh.Clone(meshData.Mesh.Options.Value, meshData.Mesh.VertexFormat | VertexFormats.Normal, dev);
meshData.Mesh = tempMesh;
meshData.Mesh.ComputeNormals();
}
mesh.SetMaterials(materials);
mesh.SetAdjacency(adjacency);
Texture[] meshTextures = new Texture[materials.Length];
for (int i = 0; i < materials.Length; i++)
{
if (!string.IsNullOrEmpty(materials[i].TextureFilename))
{
meshTextures[i] = TextureLoader.FromStream(dev, ResourcesLoader.LoadStream(materials[i].TextureFilename));
}
}
mesh.meshTextures = meshTextures;
mesh.MeshData = meshData;
if (skinInfo != null)
{
mesh.SkinInformation = skinInfo;
int numBones = skinInfo.NumberBones;
Matrix[] offsetMatrices = new Matrix[numBones];
for (int i = 0; i < numBones; i++)
{
offsetMatrices[i] = skinInfo.GetBoneOffsetMatrix(i);
}
mesh.offsetMatrices = offsetMatrices;
MeshContainerDerived.GenerateSkinnedMesh(mesh);
}
return(mesh);
}
private void DrawFrame(FrameDerived frame, Device device)
{
MeshContainerDerived mesh = (MeshContainerDerived)frame.MeshContainer;
while (mesh != null)
{
DrawMeshContainer(mesh, frame, device);
mesh = (MeshContainerDerived)mesh.NextContainer;
}
if (frame.FrameSibling != null)
{
DrawFrame((FrameDerived)frame.FrameSibling, device);
}
if (frame.FrameFirstChild != null)
{
DrawFrame((FrameDerived)frame.FrameFirstChild, device);
}
}
public void SetupBoneMatrices(MeshContainerDerived mesh)
{
if (mesh.SkinInformation != null)
{
int numBones = mesh.SkinInformation.NumberBones;
FrameDerived[] frameMatrices = new FrameDerived[numBones];
for (int i = 0; i < numBones; i++)
{
FrameDerived frame = (FrameDerived)Frame.Find(rootFrame.FrameHierarchy, mesh.SkinInformation.GetBoneName(i));
if (frame == null)
{
throw new ArgumentException();
}
frameMatrices[i] = frame;
}
mesh.frameMatrices = frameMatrices;
}
}
public static void GenerateSkinnedMesh(MeshContainerDerived mesh)
{
if (mesh.SkinInformation == null)
{
throw new ArgumentException();
}
int numInfl = 0;
BoneCombination[] bones;
MeshData m = mesh.MeshData;
m.Mesh = mesh.SkinInformation.ConvertToBlendedMesh(m.Mesh, MeshFlags.Managed | MeshFlags.OptimizeVertexCache, mesh.GetAdjacencyStream(), out numInfl, out bones);
mesh.numberInfluences = numInfl;
mesh.bones = bones;
mesh.numberAttributes = bones.Length;
mesh.MeshData = m;
}
