public class Tiny : AnimatedCharacter
	{
		protected string filename = "tiny.x";
		protected Device device;
		protected AnimationRootFrame rootFrame;
		protected MeshContainerEx meshCont;
		protected float radius = 0.0f;
		protected Vector3 center = Vector3.Empty;
		protected float angle = 0.005F;

		#region Accessor Functions
		public float Radius
		{
			get{ return this.radius; }
		}

		public Vector3 objectCenter
		{
			get{ return this.center; }
		}
		#endregion

		public Tiny(Device device)
		{
			// Set the device
			this.device = device;

			// load in everything
			rootFrame = Mesh.LoadHierarchyFromFile(filename, MeshFlags.SystemMemory, device, new FrameAllocate(filename), null );

			// calculate the radius
			radius = Frame.CalculateBoundingSphere( rootFrame.FrameHierarchy, out center );

			// map
			MapFramesToBone();

			for( int i=0; i<animControl.NumberAnimationSets; ++i )
			{
				AnimationSet animSet = animControl.GetAnimationSet(i);

				rootFrame.AnimationController.SetTrackEnable(i,true);
				rootFrame.AnimationController.SetTrackAnimationSet(i,animSet);
				rootFrame.AnimationController.ResetTime();
				rootFrame.AnimationController.SetTrackPosition(0, 0.0F);
				rootFrame.AnimationController.SetTrackSpeed(0, 1f);
				rootFrame.AnimationController.SetTrackWeight(0, 1f);

				for( int j=0; j<animSet.NumberAnimations; ++j )
				{
					string animName = animSet.GetAnimationName(j);
					int index = animSet.GetAnimationIndex(animName);
				}
			}
		}

		public override void Update()
		{
			((FrameEx)rootFrame.FrameHierarchy).UpdateHierarchy(Matrix.Identity);

			FindMeshContainerFrame( this.rootFrame.FrameHierarchy as FrameEx );
			int NumBones = meshCont.SkinInformation.NumberBones;

			for(int Counter = 0; Counter < NumBones; Counter++)
			{
				meshCont.BoneMatrices[Counter] = meshCont.SkinInformation.GetBoneOffsetMatrix(Counter);
				meshCont.BoneMatrices[Counter] *= meshCont.FrameMatrices[Counter];
			}

			GraphicsStream Src = meshCont.MeshData.Mesh.LockVertexBuffer(LockFlags.ReadOnly);
			GraphicsStream Des = meshCont.originalMesh.LockVertexBuffer(0);
			meshCont.SkinInformation.UpdateSkinnedMesh(meshCont.BoneMatrices, null, Src, Des);

			meshCont.MeshData.Mesh.UnlockVertexBuffer();
			meshCont.originalMesh.UnlockVertexBuffer();
		}

		public override void RenderFrame(float ElapsedTime)
		{
			Update();
			rootFrame.AnimationController.AdvanceTime( ElapsedTime );
			DrawFrame( rootFrame.FrameHierarchy as FrameEx );
		}

		private void DrawFrame(FrameEx frame)
		{
			MeshContainerEx mesh = frame.MeshContainer as MeshContainerEx;
			while(mesh != null)
			{
				DrawMeshContainer(mesh, frame);
				mesh = mesh.NextContainer as MeshContainerEx;
			}

			if (frame.FrameSibling != null)
			{
				DrawFrame(frame.FrameSibling as FrameEx);
			}

			if (frame.FrameFirstChild != null)
			{
				DrawFrame(frame.FrameFirstChild as FrameEx);
			}
		}

		private void DrawMeshContainer(MeshContainerEx mesh, FrameEx parent)
		{
			// position tiny upright
			device.Transform.World = Matrix.RotationY((float)Math.PI/(float)Math.Cos(angle));

			// Standard mesh, just draw it using FF
			device.RenderState.VertexBlend = VertexBlend.Disable;

			// Set up transforms
			//device.Transform.World = parent.matCombined * Matrix.RotationY(angle);
			angle+=0.005F;

			ExtendedMaterial[] materials = mesh.GetMaterials();
			for (int i = 0; i < materials.Length; ++i)
			{
				device.Material = materials.Material3D;
				device.SetTexture(0, mesh.textures);
				mesh.MeshData.Mesh.DrawSubset(i);
			}
		}

		protected void MapFramesToBone()
		{
			FindMeshContainerFrame( this.rootFrame.FrameHierarchy as FrameEx );
			int NumBones = meshCont.SkinInformation.NumberBones;

			meshCont.FrameMatrices = new Matrix[NumBones];
			meshCont.BoneMatrices = new Matrix[NumBones];

			for(int Counter = 0; Counter < NumBones; ++Counter)
			{
				string BoneName = meshCont.SkinInformation.GetBoneName(Counter);
				FrameEx FramePtr = Frame.Find(rootFrame.FrameHierarchy, BoneName) as FrameEx;

				if(FramePtr != null)
					meshCont.FrameMatrices[Counter] = FramePtr.matCombined;
				else
					meshCont.FrameMatrices[Counter] = Matrix.Identity;
			}
		}

		protected void FindMeshContainerFrame( FrameEx frame )
		{
			if( frame.MeshContainer == null )
			{
				if( frame.FrameSibling != null )
				{
					FindMeshContainerFrame( frame.FrameSibling as FrameEx );
				}
				if( frame.FrameFirstChild != null )
				{
					FindMeshContainerFrame( frame.FrameFirstChild as FrameEx );
				}
			}
			else
			{
				this.meshCont = frame.MeshContainer as MeshContainerEx;
			}
		}
	}

	public class MeshContainerEx : MeshContainer
	{
		public Matrix[] BoneMatrices;
		public Matrix[] FrameMatrices;
		public Texture[] textures;
		public string xFilePath;
		public Mesh originalMesh;

		public MeshContainerEx(string xFilePath, string name, MeshData meshData, ExtendedMaterial[] materials, EffectInstance[] effectInstances, GraphicsStream adjacency, SkinInformation skinInfo)
		{
			this.Name = name;
			this.MeshData = meshData;
			this.SetMaterials(materials);
			this.SetEffectInstances(effectInstances);
			this.SetAdjacency(adjacency);
			this.SkinInformation = skinInfo;
			this.xFilePath = xFilePath;

			// Load the textures for the mesh.
			ExtendedMaterial[] m = this.GetMaterials();
			this.textures = new Texture[m.Length];

			for(int i=0; i<m.Length; i++)
			{
				if(m.TextureFilename != null)
				{
					string path = Path.Combine(Path.GetDirectoryName(this.xFilePath), m.TextureFilename);
					this.textures = TextureLoader.FromFile(this.MeshData.Mesh.Device, path);
				}
			}

			originalMesh = this.MeshData.Mesh.Clone( MeshFlags.SystemMemory, MeshData.Mesh.VertexFormat, MeshData.Mesh.Device );
		}
	}

	public class FrameAllocate : AllocateHierarchy
	{
		private string xFilePath;

		public FrameAllocate(string xFilePath) : base()
		{
			this.xFilePath = xFilePath;
		}

		public override Frame CreateFrame(string name)
		{
			return new FrameEx(name);
		}

		public override MeshContainer CreateMeshContainer(string name, MeshData meshData, ExtendedMaterial[] materials, EffectInstance[] effectInstances, GraphicsStream adjacency, SkinInformation skinInfo)
		{
			return new MeshContainerEx(this.xFilePath, name, meshData, materials, effectInstances, adjacency, skinInfo);
		}
	}

	public class FrameEx : Frame
	{
		public Matrix matCombined = Matrix.Identity;
		public Matrix matOriginal = Matrix.Identity;

		public FrameEx(string Name)
		{
			this.Name = Name;
			this.TransformationMatrix = Matrix.Identity;
			this.MeshContainer = null;
		}

		public void Reset()
		{
			TransformationMatrix = matOriginal;

			if( ((FrameEx)this.FrameSibling) != null )
				((FrameEx)this.FrameSibling).Reset();

			if( ((FrameEx)this.FrameFirstChild) != null )
				((FrameEx)this.FrameFirstChild).Reset();
		}

		public void UpdateHierarchy(Matrix matTransformation)
		{
			matCombined = TransformationMatrix * matTransformation;

			if( ((FrameEx)this.FrameSibling) != null )
				((FrameEx)this.FrameSibling).UpdateHierarchy(matTransformation);

			if( ((FrameEx)this.FrameFirstChild) != null )
				((FrameEx)this.FrameFirstChild).UpdateHierarchy(matCombined);
		}
	}

using System;using System.IO;using Microsoft.DirectX;using Microsoft.DirectX.Direct3D;namespace Fadi.XFileAnimation{    public class XFileAnim    {		//Public mumbers		public float objectRadius = 0.0f;		public Vector3 objectCenter;		public AnimationController Controller=null;		public Matrix World=Matrix.Identity;		private Device device=null;		private AnimationRootFrame rootFrame; 		private bool isDestroyed = false;		/// <summary>Create a new instance of the class</summary>        public XFileAnim(Device dev)         { 			device=dev;        }        public void LoadFromFile(string meshFile)        {            // Create our allocate hierarchy derived class            AnimationAllocation alloc = new AnimationAllocation(this);            rootFrame = Mesh.LoadHierarchyFromFile(meshFile, MeshFlags.Managed, device, alloc, null);            // Calculate the center and radius of a bounding sphere            objectRadius = Frame.CalculateBoundingSphere(rootFrame.FrameHierarchy,                 out objectCenter);            // Setup the matrices for animation            SetupBoneMatrices(rootFrame.FrameHierarchy as AnimationFrame);			//Clone the Animation controler to add more animation tracks			if (rootFrame.AnimationController!=null)				Controller=rootFrame.AnimationController.Clone(50,30,10,30);            isDestroyed = false;        }                public void Destroy()        {            if (isDestroyed)                return; // Only clean up once            Frame.Destroy(rootFrame.FrameHierarchy, new AnimationAllocation(this));            if (rootFrame.AnimationController != null)            {                rootFrame.AnimationController.Dispose();            }            isDestroyed = true;        }        public void FrameMove(Matrix ViewWorldMatrix,float elapsedTime)        {            // Build the world matrix            Matrix worldMatrix = Matrix.Translation(-objectCenter);            worldMatrix *= ViewWorldMatrix;            // Set world matrix            device.Transform.World = worldMatrix;            // Has any time elapsed?            if (elapsedTime > 0.0f)            {                if (Controller != null)                    Controller.AdvanceTime(elapsedTime);                UpdateFrameMatrices(rootFrame.FrameHierarchy as AnimationFrame,worldMatrix);            }        }        public void Render()        {			DrawFrame(rootFrame.FrameHierarchy as AnimationFrame);        }        /// <summary>Update the frames matrices and combine it with it's parents</summary>        private void UpdateFrameMatrices(AnimationFrame frame, Matrix parentMatrix)        {            frame.CombinedTransformationMatrix = frame.TransformationMatrix *                 parentMatrix;            if (frame.FrameSibling != null)            {                UpdateFrameMatrices(frame.FrameSibling as AnimationFrame, parentMatrix);            }            if (frame.FrameFirstChild != null)            {                UpdateFrameMatrices(frame.FrameFirstChild as AnimationFrame,                     frame.CombinedTransformationMatrix);            }        }        /// <summary>Draw a frame and all child and sibling frames</summary>        private void DrawFrame(AnimationFrame frame)        {            AnimationMeshContainer mesh = frame.MeshContainer as AnimationMeshContainer;            while(mesh != null)            {                DrawMeshContainer(mesh, frame);                mesh = mesh.NextContainer as AnimationMeshContainer;            }            if (frame.FrameSibling != null)            {                DrawFrame(frame.FrameSibling as AnimationFrame);            }            if (frame.FrameFirstChild != null)            {                DrawFrame(frame.FrameFirstChild as AnimationFrame);            }        }        /// <summary>Render a mesh container</summary>        private void DrawMeshContainer(AnimationMeshContainer mesh, AnimationFrame parent)        {            // first check for skinning            if (mesh.SkinInformation != null)            {                if (mesh.NumberInfluences == 1)					device.RenderState.VertexBlend = VertexBlend.ZeroWeights;                else                    device.RenderState.VertexBlend = (VertexBlend)(mesh.NumberInfluences - 1);                if (mesh.NumberInfluences > 0)                    device.RenderState.IndexedVertexBlendEnable = true;                BoneCombination[] bones = mesh.GetBones();                for(Int32 iAttrib = 0; iAttrib < mesh.NumberAttributes; iAttrib++)                {                    // first, get world matrices                    for (int iPaletteEntry = 0; iPaletteEntry < mesh.NumberPaletteEntries;                         ++iPaletteEntry)                    {                        int iMatrixIndex = bones[iAttrib].BoneId[iPaletteEntry];                        if (iMatrixIndex != -1)                        {                            device.Transform.SetWorldMatrixByIndex(iPaletteEntry,                                 mesh.GetOffsetMatrices()[iMatrixIndex] *                                 mesh.GetFrames()[iMatrixIndex].                                CombinedTransformationMatrix*World);                        }                    }                    // Setup the material                    device.Material = mesh.GetMaterials()[bones[iAttrib].AttributeId].Material3D;                    device.SetTexture(0, mesh.GetTextures()[bones[iAttrib].AttributeId]);                    // Finally draw the subset                    mesh.MeshData.Mesh.DrawSubset(iAttrib);                }            }            else            {                // Standard mesh, just draw it using FF                device.RenderState.VertexBlend = VertexBlend.Disable;                // Set up transforms                device.Transform.World = parent.CombinedTransformationMatrix*World;                ExtendedMaterial[] materials = mesh.GetMaterials();                for (int i = 0; i < materials.Length; ++i)                {                    device.Material = materials.Material3D;                    device.SetTexture(0, mesh.GetTextures());                    mesh.MeshData.Mesh.DrawSubset(i);                }            }        }        /// <summary>        /// Generate the skinned mesh information        /// </summary>        public void GenerateSkinnedMesh(AnimationMeshContainer mesh)        {            if (mesh.SkinInformation == null)                throw new ArgumentException();  // There is nothing to generate            MeshFlags flags = MeshFlags.OptimizeVertexCache;            Caps caps = device.DeviceCaps;            if (caps.VertexShaderVersion >= new Version(1,1))            {                flags |= MeshFlags.Managed;            }            else            {                flags |= MeshFlags.SystemMemory;            }            int numMaxFaceInfl;            using(IndexBuffer ib = mesh.MeshData.Mesh.IndexBuffer)            {                numMaxFaceInfl = mesh.SkinInformation.GetMaxFaceInfluences(ib,                     mesh.MeshData.Mesh.NumberFaces);            }            // 12 entry palette guarantees that any triangle (4 independent             // influences per vertex of a tri) can be handled            numMaxFaceInfl = (int)Math.Min(numMaxFaceInfl, 12);            if (caps.MaxVertexBlendMatrixIndex + 1 >= numMaxFaceInfl)            {                mesh.NumberPaletteEntries = (int)Math.Min((caps.                    MaxVertexBlendMatrixIndex+ 1) / 2,                     mesh.SkinInformation.NumberBones);                flags |= MeshFlags.Managed;            }            int influences = 0;            BoneCombination[] bones = null;            // Use ConvertToBlendedMesh to generate a drawable mesh            MeshData data = mesh.MeshData;            data.Mesh = mesh.SkinInformation.ConvertToIndexedBlendedMesh(data.Mesh, flags,                 mesh.GetAdjacencyStream(), mesh.NumberPaletteEntries, out influences,                 out bones);            // Store this info            mesh.NumberInfluences = influences;            mesh.SetBones(bones);            // Get the number of attributes            mesh.NumberAttributes = bones.Length;            mesh.MeshData = data;        }        /// <summary>This method will set the bone matrices for a frame</summary>        private void SetupBoneMatrices(AnimationFrame frame)        {            // First do the mesh container this frame contains (if it does)            if (frame.MeshContainer != null)            {                SetupBoneMatrices(frame.MeshContainer as AnimationMeshContainer);            }            // Next do any siblings this frame may contain            if (frame.FrameSibling != null)            {                SetupBoneMatrices(frame.FrameSibling as AnimationFrame);            }            // Finally do the children of this frame            if (frame.FrameFirstChild != null)            {                SetupBoneMatrices(frame.FrameFirstChild as AnimationFrame);            }        }        /// <summary>Sets the bone matrices for a mesh container</summary>        private void SetupBoneMatrices(AnimationMeshContainer mesh)        {            // Is there skin information?  If so, setup the matrices            if (mesh.SkinInformation != null)            {                int numberBones = mesh.SkinInformation.NumberBones;                AnimationFrame[] frameMatrices = new AnimationFrame[numberBones];                for(int i = 0; i< numberBones; i++)                {                    AnimationFrame frame = Frame.Find(rootFrame.FrameHierarchy,                         mesh.SkinInformation.GetBoneName(i)) as AnimationFrame;                    if (frame == null)                        throw new InvalidOperationException("Could not find valid bone.");                    frameMatrices = frame;                }                mesh.SetFrames(frameMatrices);            }        }		public AnimationFrame GetFrameByName(string FrameName)		{			AnimationFrame Result=Frame.Find(rootFrame.FrameHierarchy,FrameName) as AnimationFrame;			return Result;		}		public void GetMeshBoundingBox(AnimationFrame Frame,out Vector3 MinVec,out Vector3 MaxVec)		{			AnimationMeshContainer Cont=(AnimationMeshContainer)Frame.MeshContainer;			Mesh mesh=Cont.MeshData.Mesh;			using (VertexBuffer vb = mesh.VertexBuffer)			{				GraphicsStream vertexData = vb.Lock(0, 0, LockFlags.None);				Geometry.ComputeBoundingBox(vertexData,mesh.NumberVertices,					mesh.VertexFormat,out MinVec,out MaxVec);				vb.Unlock();			}		}	}    #region Derived Frame Class    /// <summary>    /// The frame that will hold mesh animation     /// </summary>    public class AnimationFrame : Frame    {        // Store the combined transformation matrix		private Matrix combined = Matrix.Identity;        /// <summary>The combined transformation matrix</summary>        public Matrix CombinedTransformationMatrix		{            get { return combined; } set { combined = value; }        }    }    #endregion    #region Derived Mesh Container    /// <summary>    /// The mesh container class that will hold the animation data    /// </summary>    public class AnimationMeshContainer : MeshContainer    {        // Array data		private Texture[] meshTextures = null;		private BoneCombination[] bones;		private Matrix[] offsetMatrices;		private AnimationFrame[] frameMatrices;		//private IndexBuffer ib;        // Instance data		private int numAttributes = 0;		private int numInfluences = 0;		private int numPalette = 0;        // Public properties        /// <summary>Retrieve the textures used for this container</summary>        public Texture[] GetTextures() { return meshTextures; }        /// <summary>Set the textures used for this container</summary>        public void SetTextures(Texture[] textures) { meshTextures = textures; }                /// <summary>Retrieve the bone combinations used for this container</summary>        public BoneCombination[] GetBones() { return bones; }        /// <summary>Set the bone combinations used for this container</summary>        public void SetBones(BoneCombination[] b) { bones = b; }                /// <summary>Retrieve the animation frames used for this container</summary>        public AnimationFrame[] GetFrames() { return frameMatrices; }        /// <summary>Set the animation frames used for this container</summary>        public void SetFrames(AnimationFrame[] frames) { frameMatrices = frames; }                /// <summary>Retrieve the offset matrices used for this container</summary>        public Matrix[] GetOffsetMatrices() { return offsetMatrices; }        /// <summary>Set the offset matrices used for this container</summary>        public void SetOffsetMatrices(Matrix[] matrices) { offsetMatrices = matrices; }                /// <summary>Total number of attributes this mesh container contains</summary>        public int NumberAttributes { get { return numAttributes; } set { numAttributes = value; } }        /// <summary>Total number of influences this mesh container contains</summary>        public int NumberInfluences { get { return numInfluences; } set { numInfluences = value; } }        /// <summary>Total number of palette entries this mesh container contains</summary>        public int NumberPaletteEntries { get { return numPalette; } set { numPalette = value; } }    }    #endregion    #region Animation Allocation Hierarchy    /// <summary>    /// AllocateHierarchy derived class    /// </summary>    public class AnimationAllocation : AllocateHierarchy    {        XFileAnim parent = null;        /// <summary>Create new instance of this class</summary>        public AnimationAllocation(XFileAnim p) { parent = p; }        /// <summary>Create a new frame</summary>        public override Frame CreateFrame(string name)        {            AnimationFrame frame = new AnimationFrame();            frame.Name = name;            frame.TransformationMatrix = Matrix.Identity;            frame.CombinedTransformationMatrix = Matrix.Identity;            return frame;        }        /// <summary>Create a new mesh container</summary>        public override MeshContainer CreateMeshContainer(string name,             MeshData meshData, ExtendedMaterial[] materials,             EffectInstance[] effectInstances, GraphicsStream adjacency,             SkinInformation skinInfo)        {            // We only handle meshes here            if (meshData.Mesh == null)                throw new ArgumentException();            // We must have a vertex format mesh            if (meshData.Mesh.VertexFormat == VertexFormats.None)                throw new ArgumentException();            AnimationMeshContainer mesh = new AnimationMeshContainer();            mesh.Name = name;            int numFaces = meshData.Mesh.NumberFaces;            Device dev = meshData.Mesh.Device;                        // Make sure there are normals            if ((meshData.Mesh.VertexFormat & VertexFormats.Normal) == 0)            {                // Clone the mesh                Mesh tempMesh = meshData.Mesh.Clone(meshData.Mesh.Options.Value,                     meshData.Mesh.VertexFormat | VertexFormats.Normal, dev);                // Destroy current mesh, use the new one                meshData.Mesh.Dispose();                meshData.Mesh = tempMesh;                meshData.Mesh.ComputeNormals();            }            // Store the materials            mesh.SetMaterials(materials);            mesh.SetAdjacency(adjacency);            Texture[] meshTextures = new Texture[materials.Length];                        // Create any textures            for (int i = 0; i < materials.Length; i++)            {                if ((materials.TextureFilename != null)&&(File.Exists(materials.TextureFilename)))                {					meshTextures = TextureLoader.FromFile(dev, materials.TextureFilename);//                  meshTextures = ResourceCache.GetGlobalInstance().CreateTextureFromFile(//                        dev, materials.TextureFilename);                }            }            mesh.SetTextures(meshTextures);            mesh.MeshData = meshData;            // If there is skinning info, save any required data            if (skinInfo != null)            {                mesh.SkinInformation = skinInfo;                int numBones = skinInfo.NumberBones;                Matrix[] offsetMatrices = new Matrix[numBones];                for (int i = 0; i < numBones; i++)                    offsetMatrices = skinInfo.GetBoneOffsetMatrix(i);                mesh.SetOffsetMatrices(offsetMatrices);                parent.GenerateSkinnedMesh(mesh);            }            return mesh;        }    }    #endregion}

//declaringXFileAnim KBody;//for loadingKBody=new XFileAnim(device);KBody.LoadFromFile("KhBody.X");//synchronize with the application timefloat ElapsedTime=(float)FrameworkTimer.GetElapsedTime();KBody.FrameMove(Matrix.Identity, ElapsedTime);//Rendering and moving according to the matrix MeshMoveMatrixKBody.World=MeshMoveMatrix;KBody.Render();