D:/guillaume/guillara/3D/DXGfx/Backup/DXGfxLib/ArticulatedModel.cs

Go to the documentation of this file.

//BSD License  
//DXGfx® - http://www.eteractions.com
//Copyright (c) 2005
//by Guillaume Randon
//Permission is hereby granted, free of charge, to any person obtaining a copy of this software
//and associated documentation files (the "Software"), to deal in the Software without restriction,
//including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
//and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so,
//subject to the following conditions:
//The above copyright notice and this permission notice shall be included in all copies or substantial
//portions of the Software.
//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
//INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE 
//AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
//DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
using Microsoft.DirectX;
using Microsoft.DirectX.Direct3D;
using Microsoft.Samples.DirectX.UtilityToolkit;

namespace DXGfxLib
{
    internal class EnhancedFrame : Frame
    {
                public Matrix frameWorldMat;

        public AABBox boundingBox;

        public EnhancedFrame()
                {
            frameWorldMat = Matrix.Identity;
                }
    }

    internal class EnhancedMeshContainer : MeshContainer
    {
        public Mesh oriMesh = null;

        public bool hasSkin = false;

        public Mesh BlendedMesh;

        public BoneCombination[] BoneCombinations;

        public int numMaterials = 0;
        public Microsoft.DirectX.Direct3D.Material[] materials;

        public Texture[] textures;

        public int MaxFaceInfluences = 0;

        public Matrix[] BoneOffsetMatrices;

        public EnhancedFrame[] AffectingBones;

        public EffectInstance[] EffectInstances;

        public AABBox localBoundingBox;
    }

    internal class EnhancedAllocateHierarchy : AllocateHierarchy
    {
        public override Frame CreateFrame(string name)
        {
            EnhancedFrame frame = new EnhancedFrame();
            frame.Name = name;

            return frame;
        }

        public override MeshContainer CreateMeshContainer(string name, MeshData meshData, ExtendedMaterial[] materials, EffectInstance[] effectInstances, GraphicsStream adjacency, SkinInformation skinInfo)
        {
            EnhancedMeshContainer container = new EnhancedMeshContainer();

            container.Name = name;

            // meshData
            container.MeshData = meshData;


            container.oriMesh = meshData.Mesh;
            container.localBoundingBox = AABBox.CalculateLocalBBox(container.oriMesh);
           

            // materials
            if (materials != null)
                container.SetMaterials(materials);

            // skinInfo
            if (skinInfo != null)
                container.SkinInformation = skinInfo;

            // effectIntances
            if (effectInstances != null)
                container.EffectInstances = effectInstances;

            // adjacency
            if (adjacency != null)
                container.SetAdjacency(adjacency);
            else
            {
                throw new NullReferenceException("adjancy null!");
            }

            // materials and textures
            if (materials != null)
            {
                container.materials = new Microsoft.DirectX.Direct3D.Material[materials.Length];
                container.textures = new Texture[materials.Length];
                container.numMaterials = materials.Length;

                for (int i = 0; i < materials.Length; i++)
                {
                    // Copy the material
                    container.materials[i] = materials[i].Material3D;

                    // Set the ambient color for the material (D3DX does not do this)
                    container.materials[i].Ambient = container.materials[i].Diffuse;

                    // Create the texture
                    if (materials[i].TextureFilename != null)
                    {
                        if (File.Exists(materials[i].TextureFilename))
                            container.textures[i] = ResourceCache.GetGlobalInstance().CreateTextureFromFile(ArticulatedModel.currentDevice, materials[i].TextureFilename);
                        else
                        {
                            throw new Exception("Texture file for material not found!");
                        }
                    }
                }
            }

            if (skinInfo != null)
            {
                container.BoneOffsetMatrices = new Matrix[skinInfo.NumberBones];

                for (int i = 0; i < skinInfo.NumberBones; i++)
                    container.BoneOffsetMatrices[i] = skinInfo.GetBoneOffsetMatrix(i);

                container.BlendedMesh = skinInfo.ConvertToBlendedMesh(
                    container.MeshData.Mesh, MeshFlags.Managed, container.GetAdjacencyStream(),
                    out container.MaxFaceInfluences, out container.BoneCombinations);
            }

            return container;
        }
    }

    public class ArticulatedModel : MeshObject
    {
        public static Device currentDevice = null;

        protected AnimationRootFrame rootFrame;

        public bool HasSkin = false;

        private int currentAnimationTrack = 1;

        public float animationTransitionTime = 0.5f;

        public double currentTime;

        public ArticulatedModel()
        {
        }

        public override void LoadFromFile(Device d3ddevice, string fileName)
        {
            // This will be used to populate fields used by SceneObject code (intersections and everything which at the moment
            // have not been overriden (yet)).
            //Attach(new FrameworkMesh(d3ddevice, fileName));

            currentDevice = d3ddevice;
            rootFrame = Mesh.LoadHierarchyFromFile(fileName, MeshFlags.Managed, d3ddevice, new EnhancedAllocateHierarchy(), null);

            SetupBonePointersOnMesh(rootFrame.FrameHierarchy);
        }

        protected void SetupBonePointersOnMesh(Frame frame)
        {
            // If this frame has a mesh container, store pointers to all frames (bones) that affect this mesh.
            if (frame.MeshContainer != null)
            {
                EnhancedMeshContainer meshContainer = (EnhancedMeshContainer)frame.MeshContainer;
                SkinInformation skinInformation = meshContainer.SkinInformation;

                if (skinInformation != null)
                {
                    HasSkin = true;
                    meshContainer.AffectingBones = new EnhancedFrame[skinInformation.NumberBones];

                    for (int i = 0; i < skinInformation.NumberBones; i++)
                    {
                        EnhancedFrame affectingBone = (EnhancedFrame)Frame.Find(rootFrame.FrameHierarchy,
                            skinInformation.GetBoneName(i));
                        meshContainer.AffectingBones[i] = affectingBone;
                    }
                }
            }

            // Perform this operation recursively
            if (frame.FrameSibling != null) SetupBonePointersOnMesh(frame.FrameSibling);

            if (frame.FrameFirstChild != null) SetupBonePointersOnMesh(frame.FrameFirstChild);
        }

        public override void Update(Frustrum frustrum, double appTime, float elapsedTime)
        {
            base.Update(frustrum, appTime, elapsedTime);

            rootFrame.AnimationController.AdvanceTime(elapsedTime, null);
            UpdateFrameMatrices(rootFrame.FrameHierarchy, WorldMat);
        }

        protected void UpdateFrameMatrices(Frame frame, Matrix parentMat)
        {
            BBox framebbox = null;

            EnhancedFrame enhancedFrame = frame as EnhancedFrame;
            if (enhancedFrame != null)
            {
                enhancedFrame.frameWorldMat = Matrix.Multiply(frame.TransformationMatrix, parentMat);
                if (enhancedFrame.MeshContainer != null)
                {
                    EnhancedMeshContainer enMeshCont = enhancedFrame.MeshContainer as EnhancedMeshContainer;
                    if (enMeshCont != null)
                    {
                        framebbox = enMeshCont.localBoundingBox.Transform(enhancedFrame.frameWorldMat);
                    }
                }
            }

            if (frame.FrameSibling != null)
            {
                UpdateFrameMatrices(frame.FrameSibling, parentMat);
                EnhancedFrame enFrame = frame.FrameSibling as EnhancedFrame;
                if (enFrame != null)
                {
                    if (framebbox != null)
                    {
                        framebbox = AABBox.BoxFromBoxes(new AABBox(framebbox), enFrame.boundingBox);
                    }
                    else
                    {
                        framebbox = enFrame.boundingBox;
                    }
                }
            }

            if ((frame.FrameFirstChild != null) && (enhancedFrame != null))
            {
                UpdateFrameMatrices(frame.FrameFirstChild, enhancedFrame.frameWorldMat);
                EnhancedFrame enFrame = frame.FrameFirstChild as EnhancedFrame;
                if (enFrame != null)
                {
                    if (framebbox != null)
                    {
                        framebbox = AABBox.BoxFromBoxes(new AABBox(framebbox), enFrame.boundingBox);
                    }
                    else
                    {
                        framebbox = enFrame.boundingBox;
                    }
                }
            }

            if (enhancedFrame != null)
            {
                if (framebbox == null)
                {
                    framebbox = new BBox();
                }
                enhancedFrame.boundingBox = new AABBox(framebbox);
            }
        }

        protected void RenderFrame(Device d3ddevice, Frame frame)
        {
            // Check if this is a mesh frame
            if (frame.MeshContainer != null)
            {
                EnhancedMeshContainer meshContainer = (EnhancedMeshContainer)frame.MeshContainer;

                // Standard mesh. Draw it the simple way.
                if (meshContainer.SkinInformation == null)
                {
                    EnhancedFrame frameDerived = (EnhancedFrame)frame;
                    d3ddevice.SetTransform(TransformType.World, frameDerived.frameWorldMat);
                    for (int i = 0; i < meshContainer.materials.Length; i++)
                    {
                        d3ddevice.Material = meshContainer.materials[i];
                        if (meshContainer.textures[i] != null)
                            d3ddevice.SetTexture(0, meshContainer.textures[i]);
                        meshContainer.MeshData.Mesh.DrawSubset(i);
                    }
                }
                // Animated mesh.
                else
                {
                    // Loop all mesh subsets (bone combinations)
                    int lastAttribId = -1;
                    for (int j = 0; j < meshContainer.BoneCombinations.Length; j++)
                    {
                        BoneCombination boneCombination = meshContainer.BoneCombinations[j];

                        d3ddevice.SetTransform(TransformType.World, Matrix.Identity);
                        d3ddevice.SetTransform(TransformType.World1, Matrix.Identity);
                        d3ddevice.SetTransform(TransformType.World2, Matrix.Identity);
                        d3ddevice.SetTransform(TransformType.World3, Matrix.Identity);

                        // Set the matrices for this subset
                        int blendCount = 0;
                        for (int i = 0; i < meshContainer.MaxFaceInfluences; i++)
                        {
                            int boneMatrixId = boneCombination.BoneId[i];

                            if (boneMatrixId != -1)
                            {
                                blendCount = i;

                                Matrix transformMatrix = Matrix.Multiply(meshContainer.BoneOffsetMatrices[boneMatrixId],
                                    meshContainer.AffectingBones[boneMatrixId].frameWorldMat);

                                if (i == 0) d3ddevice.SetTransform(TransformType.World, transformMatrix);
                                else if (i == 1) d3ddevice.SetTransform(TransformType.World1, transformMatrix);
                                else if (i == 2) d3ddevice.SetTransform(TransformType.World2, transformMatrix);
                                else if (i == 3) d3ddevice.SetTransform(TransformType.World3, transformMatrix);
                            }
                        }

                        // Set vertex blend count
                        if (blendCount == 1) d3ddevice.RenderState.VertexBlend = VertexBlend.OneWeights;
                        else if (blendCount == 2) d3ddevice.RenderState.VertexBlend = VertexBlend.TwoWeights;
                        else if (blendCount == 3) d3ddevice.RenderState.VertexBlend = VertexBlend.ThreeWeights;
                        else d3ddevice.RenderState.VertexBlend = VertexBlend.Disable;

                        // If the material is different than the last subset, update the device material
                        if (lastAttribId != boneCombination.AttributeId)
                        {
                            lastAttribId = boneCombination.AttributeId;
                            d3ddevice.Material = meshContainer.materials[lastAttribId];
                            d3ddevice.SetTexture(0, meshContainer.textures[lastAttribId]);
                        }

                        // Render the mesh
                        meshContainer.BlendedMesh.DrawSubset(j);
                    }

                    // Rendering is finished, set the vertex blending back to disabled mode
                    d3ddevice.RenderState.VertexBlend = VertexBlend.Disable;
                }
            }

            // Do this recursively on all child Frames and all Frames at the same level.
            if (frame.FrameSibling != null) RenderFrame(d3ddevice, frame.FrameSibling);
            if (frame.FrameFirstChild != null) RenderFrame(d3ddevice, frame.FrameFirstChild);
        }

        public override void Draw(Device device)
        {
            device.SetTransform(TransformType.World, worldMat);
            RenderFrame(device, rootFrame.FrameHierarchy);
        }

        public List<String> GetAnimationList()
        {
            List<String> animations = new List<string>();
            for (int i = 0; i < rootFrame.AnimationController.MaxNumberAnimationSets; i++)
            {
                animations.Add(rootFrame.AnimationController.GetAnimationSet(i).Name);
            }
            return animations;
        }

        public void StartAnimation(string animationName)
        {
            AnimationSet animSet = rootFrame.AnimationController.GetAnimationSet(animationName);

            if (animSet == null)
            {
                return;
            }

            int newAnimationTrack = (currentAnimationTrack == 0 ? 1 : 0);

            rootFrame.AnimationController.SetTrackAnimationSet(newAnimationTrack, animSet);

            rootFrame.AnimationController.UnkeyAllTrackEvents(currentAnimationTrack);
            rootFrame.AnimationController.UnkeyAllTrackEvents(newAnimationTrack);

            rootFrame.AnimationController.KeyTrackEnable(currentAnimationTrack, false, currentTime + animationTransitionTime);
            rootFrame.AnimationController.KeyTrackSpeed(currentAnimationTrack, 0.0f, currentTime, animationTransitionTime, TransitionType.Linear);
            rootFrame.AnimationController.KeyTrackWeight(currentAnimationTrack, 0.0f, currentTime, animationTransitionTime, TransitionType.Linear);

            rootFrame.AnimationController.KeyTrackEnable(newAnimationTrack, true, currentTime + animationTransitionTime);
            rootFrame.AnimationController.KeyTrackSpeed(newAnimationTrack, 1.0f, currentTime, animationTransitionTime, TransitionType.Linear);
            rootFrame.AnimationController.KeyTrackWeight(newAnimationTrack, 1.0f, currentTime, animationTransitionTime, TransitionType.Linear);

            currentAnimationTrack = newAnimationTrack;

        }

        public void StopAll()
        {
            rootFrame.AnimationController.UnkeyAllTrackEvents(currentAnimationTrack);

            rootFrame.AnimationController.KeyTrackEnable(currentAnimationTrack, false, currentTime + animationTransitionTime);
            rootFrame.AnimationController.KeyTrackSpeed(currentAnimationTrack, 0.0f, currentTime, animationTransitionTime, TransitionType.Linear);
            rootFrame.AnimationController.KeyTrackWeight(currentAnimationTrack, 0.0f, currentTime, animationTransitionTime, TransitionType.Linear);
        }
    }
}

---