//---------------------------------------------------------------------------------------------------------------------------------------------------
// <copyright file="GameObject.cs" company="DarkWynter Studios">
//     Copyright (C)2007 DarkWynter Studios.  All rights reserved.
// </copyright>
//---------------------------------------------------------------------------------------------------------------------------------------------------
// {Contact : darkwynter.com for licensing information
//---------------------------------------------------------------------------------------------------------------------------------------------------

namespace DarkWynterEngine.GameObjects
{
    #region Using Statements
    using System;
    using System.Collections.Generic;
    using Microsoft.Xna.Framework;
    using Microsoft.Xna.Framework.Graphics;
    using System.Xml;

    using Physics;
    using Globals;
    using ObjectLib;
    #endregion




    /// <summary>
    /// Used to pass instance data to shaders through existing gpu pipelines.
    ///
    /// Location and orientation variables are stored as follows:
    /// Fog         = GameObject scale
    /// Binormal    = GameObject rotation
    /// Tangent     = GameObject position
    /// </summary>
    public struct VertexFogBinormalTangent
    {
        /// <summary>
        /// scale
        /// </summary>
        public Vector4 Fog;
        /// <summary>
        /// rotation
        /// </summary>
        public Vector4 Binormal;
        /// <summary>
        /// position
        /// </summary>
        public Vector4 Tangent;
    }

    /// <summary>
    /// Used to pass instance data to shaders through existing gpu pipelines.
    ///
    /// World matrix values are stored  as follows:
    /// Fog         = World.M11, World.M12, World.M13, World.M14
    /// Binormal    = World.M21, World.M22, World.M23, World.M24
    /// Tangent     = World.M31, World.M32, World.M33, World.M34
    /// Weight      = World.M41, World.M42, World.M43, World.M44
    /// </summary>
    public struct VertexFogBinormalTangentWeight
    {
        /// <summary>
        /// World.M11, World.M12, World.M13, World.M14
        /// </summary>
        public Vector4 Fog;
        /// <summary>
        /// World.M21, World.M22, World.M23, World.M24
        /// </summary>
        public Vector4 Binormal;
        /// <summary>
        /// World.M31, World.M32, World.M33, World.M34
        /// </summary>
        public Vector4 Tangent;
        /// <summary>
        /// World.M41, World.M42, World.M43, World.M44
        /// </summary>
        public Vector4 BlendWeight;
    }

    /// <summary>
    /// Methods of GameObject follow the GameFlow pattern to ensure quick and efficient loading and unloading procedures.
    /// Additional properties are included in GameObject and are used by Renderer and Update to manipulate the GameObject.
    /// Each object specifies its draw and update procedures internally and is passed to Physics for in game motion and rotation.
    /// </summary>
    public class GameObject
    {
        #region GameObject Interface Properties
        private Mass _mass;
        private Model _model;
        private Matrix _matrix;
        private XmlNode _xml;

        private List<Texture2D> _textureList = new List<Texture2D>();
        private string _objectModelName;
        private bool _isCollectable;
        private bool _isKey;

        /// <summary>
        /// Mass object, handles physics of GameObject.
        /// </summary>
        public Mass mass { get { return _mass; } set { _mass = value; } }
        /// <summary>
        /// Model used by this GameObject.
        /// </summary>
        public Model model { get { return _model; } set { _model = value; } }

        /// <summary>
        /// Location and orientation matrix passed to shaders.
        /// </summary>
        public Matrix matrix { get { return _matrix; } set { _matrix = value; } }
        /// <summary>
        /// Xml data associated with this object.
        /// </summary>
        public XmlNode xml { get { return _xml; } set { _xml = value; } }

        /// <summary>
        /// Textures associated with this object.
        /// </summary>
        public List<Texture2D> textureList { get { return _textureList; } set { _textureList = value; } }
        /// <summary>
        /// Text identifier for model name.
        /// </summary>
        public string objectModelName { get { return _objectModelName; } set { _objectModelName = value; } }
        /// <summary>
        /// Defines if this object is collectable by players.
        /// </summary>
        public bool isCollectable { get { return _isCollectable; } set { _isCollectable = value; } }
        /// <summary>
        /// Defines if this object is a Key object collected to pass the level.
        /// </summary>
        public bool isKey { get { return _isKey; } set { _isKey = value; } }

        /// <summary>
        /// Buffer to store vertices
        /// </summary>
        public VertexBuffer vertexBuffer;
        /// <summary>
        /// Array to store vertex Position, Normal and Texture information
        /// </summary>
        public VertexPositionNormalTexture[] vertices;
        /// <summary>
        /// Vertex Declaration.
        /// </summary>
        public VertexDeclaration vertexDeclaration;
        /// <summary>
        /// Used to pass instance data to shader.
        /// </summary>
        public VertexFogBinormalTangent objectValues;

        /// <summary>
        /// Tangential component of force calculations.
        /// </summary>
        public Vector3 tangentialComponent = new Vector3();
        /// <summary>
        /// Normal component of force calculations.
        /// </summary>
        public Vector3 normalComponent = new Vector3();

        /// <summary>
        /// Used in collision; surface normal calculation.
        /// </summary>
        public Vector3 surfaceNormal;
        /// <summary>
        /// Used in collision; gravity normal calculation.
        /// </summary>
        public Vector3 gravityNormalComponent;
        /// <summary>
        /// Used in collision; tangential gravity-force calculation.
        /// </summary>
        public Vector3 gravityTangentialComponent;
        /// <summary>
        /// Used in collision; normal velocity-force calculation.
        /// </summary>
        public Vector3 velocityNormalComponent;
        /// <summary>
        /// Used in collision; tangential velocity-force calculation.
        /// </summary>
        public Vector3 velocityTangentialComponent;
        /// <summary>
        /// Used in collision; normal totalForce calculation.
        /// </summary>
        public Vector3 totalForceNormalComponent;
        /// <summary>
        /// Used in collision; tangential totalForce calculation.
        /// </summary>
        public Vector3 totalForceTangentialComponent;
        /// <summary>
        /// Used in collision; combined velocity and totalForce normal calculation.
        /// </summary>
        public Vector3 combinedNormalForce;
        /// <summary>
        /// Used in collision; combined velocity and totalForce tangential calculation.
        /// </summary>
        public Vector3 combinedTangentialForce;

        /// <summary>
        /// Difference between object height and terrain at it's x/z location.
        /// HeightDifference is positive when object is below the terrain.
        /// </summary>
        public float heightDifference;
        /// <summary>
        /// Terrain height at object's x/z location.
        /// </summary>
        public float localTerrainHeight;

        /// <summary>
        /// Defines what kind of collision response this GameObject should have.
        /// </summary>
        public Enums.CollisionResponses collisionWithPlayerResponse = Enums.CollisionResponses.NONE;

        /// <summary>
        /// Defines the scale of damage or health an object bestows.
        /// </summary>
        public float collisionMultiplier = 0.001f;
        #endregion

        #region Methods

        /// <summary>
        /// Game object constructor.
        /// Gets a pre-initialized mass object from the Statics.LevelSettings.darkMatter list.
        /// </summary>
        public GameObject()
        {
            mass = Statics.LevelSettings.darkMatter[Statics.LevelSettings.darkMatterIterator++];
            mass.gameObjectPointer = this;
        }


        /// <summary>
        /// Load object data from Xml.
        /// </summary>
        /// <param name="node">The Level xml node corresponding to this object</param>
        /// <param name="objectLibrary">ObjectLibrary that this object belongs to.</param>
        public virtual bool Load(XmlNode node, ObjectLibrary objectLibrary)
        {

            // Set up Model Manager
            bool success = objectLibrary.modelManager.AddNewModel(node.Attributes["type"].Value,
                           node.Attributes["model"].Value,
                           node.Attributes["texture"].Value,
                           node.Attributes["bumpTexture"].Value);

            // Return unsuccessfully if can't load user supplied XML data
            if (!success) { return true; }  // WE SHOULD RETURN FALSE HERE... OTHERWISE WE'RE SAYING "YES, IT LOADED"  WHEN IT DIDN'T

            // Get the Location Map
            Texture2D locationMap = Statics.SystemSettings.content.Load<Texture2D>(node.Attributes["locationMap"].Value);
            int length = locationMap.Width * locationMap.Width;
            Color[] locationColorValues = new Color[length];
            locationMap.GetData<Color>(locationColorValues);
            Random rand = new Random();

            // Precalculate the vertexmap/locationmap ratio for use in the for loop below
            float vertexmapToObjectmapRelationship = Statics.TerrainSettings.vertexMapSize / locationMap.Width;

            // Create a ruler 1 terrain mod long (distance between verticies
            float terrainModWidth = Statics.TerrainSettings.terrainScaleFactor * vertexmapToObjectmapRelationship;

            // Get the color value of the node
            int mapColorR = int.Parse(node.Attributes["red"].Value);
            int mapColorG = int.Parse(node.Attributes["green"].Value);
            int mapColorB = int.Parse(node.Attributes["blue"].Value);

            // For each pixel of the treeMap
            for (int l = 0; l < length; l++)
            {
                // If the color matches create a prop
                if (locationColorValues[l].R == mapColorR && locationColorValues[l].G == mapColorG && locationColorValues[l].B == mapColorB)
                {

                    // Get the 2D location from 1D array
                    int h = l % locationMap.Width;
                    int w = (int)l / locationMap.Width;

                    // Start Type properties
                    //gameObject.mass.objectType = objectType;
                    mass.gameObjectPointer = this;
                    objectModelName = node.Attributes["type"].Value;

                    // Get terrain height at position
                    float yPosition = objectLibrary.terrain.GetTerrainHeight(w * vertexmapToObjectmapRelationship,
                                                                             h * vertexmapToObjectmapRelationship);

                    // Set the object world properties
                    Vector3 locpos = new Vector3(w * terrainModWidth, yPosition, h * terrainModWidth);
                    Vector3 refpos = new Vector3(w * terrainModWidth, yPosition, h * terrainModWidth - 1);
                    mass.SetPosition(locpos, refpos);

                    mass.Rotate(0.0f, 0.0f);
                    mass.scale = new Vector3((float.Parse(node.Attributes["maxScale"].Value)));
                    mass.mass = float.Parse(node.Attributes["mass"].Value);
                    mass.isMoving = false;

                    isCollectable = bool.Parse(node.Attributes["isCollectable"].Value);
                    isKey = bool.Parse(node.Attributes["isKey"].Value);

                    if (isKey)
                    {
                        collisionWithPlayerResponse = Enums.CollisionResponses.HEALTHBONUS;
                    }

                    objectValues = new VertexFogBinormalTangent();
                    objectValues.Fog = new Vector4(mass.scale, 0.0f);                // Store the scale
                    objectValues.Binormal = new Vector4(mass.currentRotation.X,
                                                                   mass.currentRotation.Y,
                                                                   mass.currentRotation.Z,
                                                                   mass.currentRotation.W);       // Store the quaternion rotation
                    objectValues.Tangent = new Vector4(mass.currentPosition, 0.0f);

                }
            }
            return true;
        }
        
        /// <summary>
        /// Update this object
        /// </summary>
        /// <param name="objectLibrary">ObjectLibrary</param>
        public virtual void Update(ref ObjectLibrary objectLibrary)
        {
            mass.UpdatePosition();
            mass.boundingVolume.UpdateSphere(mass.currentPosition);

            objectValues = new VertexFogBinormalTangent();
            objectValues.Fog = new Vector4(mass.scale, 0.0f);          // Store the scale
            objectValues.Binormal = new Vector4(mass.currentRotation.X,
                                                mass.currentRotation.Y,
                                                mass.currentRotation.Z,
                                                mass.currentRotation.W);            // Store the quaternion rotation
            objectValues.Tangent = new Vector4(mass.currentPosition, 0.0f);         // Store the translation
        }

        /// <summary>
        /// Default behavior applies force based physics for rebound.
        /// Override to supplement behavior.
        /// Return true if collidedObject is absorbed or destroyed, else false.
        /// </summary>
        /// <param name="collidedObject">GameObject that collided with this GameObject.</param>
        /// <param name="resultantForce">The force applied by the colliding GameObject to this GameObject</param>
        /// <param name="objectLibrary">ObjectLibrary that this object belongs to.</param>
        /// <returns>True = this object has to be recycled</returns>
        public virtual bool ObjectCollisionResponse(GameObject collidedObject, Vector3 resultantForce, ObjectLibrary objectLibrary)
        {
            mass.numberOfCollision++;
            mass.isMoving = true;

            return false;
        }
        /// <summary>
        /// Default behavior applies force based physics for rebound.
        /// Override to supplement or replace behavior.
        /// </summary>
        /// <param name="terrain">A copy of the terrain, provided for overrides</param>
        public virtual void TerrainCollisionResponse(Terrain terrain)
        {
            CalculateVectorComponents(surfaceNormal, Statics.GameSettings.accelDueToGravity);
            gravityNormalComponent = normalComponent + Vector3.Zero;
            gravityTangentialComponent = tangentialComponent + Vector3.Zero;

            // Calculate the components of velocity with reference to the surface normal
            CalculateVectorComponents(surfaceNormal, mass.velocity);
            velocityNormalComponent = normalComponent + Vector3.Zero;
            velocityTangentialComponent = tangentialComponent + Vector3.Zero;

            // Calculate the components of totalForce with reference to the surface normal
            CalculateVectorComponents(surfaceNormal, mass.totalForce);
            totalForceNormalComponent = normalComponent + Vector3.Zero;
            totalForceTangentialComponent = tangentialComponent + Vector3.Zero;

            // Calculate normal and tangential forces with reference to the their components
            combinedNormalForce = (mass.mass * velocityNormalComponent / Statics.SystemSettings.dt) + totalForceNormalComponent;
            combinedTangentialForce = (mass.mass * velocityTangentialComponent / Statics.SystemSettings.dt) +
                                       totalForceTangentialComponent +
                                       (mass.mass * gravityTangentialComponent);

            mass.numberOfCollision++;
        }
        /// <summary>
        /// Calculate components of collision.
        /// </summary>
        /// <param name="surfaceNormal">Normal of surface that is being collided against.</param>
        /// <param name="objectVelocity">Velocity of this GameObject.</param>
        private void CalculateVectorComponents(Vector3 surfaceNormal, Vector3 objectVelocity)
        {
            float vectorToNormalAngle, vectorToSurfaceAngle;
            float normalComponentOfVector;

            if (objectVelocity.Length() >= 0.01f || !float.IsInfinity(objectVelocity.Length()))
            {
                normalComponent = Vector3.Dot(objectVelocity, surfaceNormal) * surfaceNormal;

                tangentialComponent = objectVelocity - normalComponent;
                /*
                // Based on vector dot product to get the angle between the two vectors
                vectorToNormalAngle = (float)Math.Acos(Vector3.Dot(surfaceNormal, objectVelocity) / objectVelocity.Length());
                // Stupid check required due to XNA's inaccuracy
                if (float.IsNaN(vectorToNormalAngle))
                {
                    vectorToNormalAngle = 0.0f;
                }

                // The angle between the ground and the vector is pi/2 - previous angle
                vectorToSurfaceAngle = (float)Math.PI / 2.0f - vectorToNormalAngle;

                // Scalar component of the vector in the the normal direction
                normalComponentOfVector = objectVelocity.Length() * (float)Math.Sin(vectorToSurfaceAngle);
                if (float.IsNaN(normalComponentOfVector))
                {
                    //if objectVelocity.Length gives an invalid value
                    normalComponentOfVector = 0.0f;
                }
                // Above scalar component multiplied by the surface normal gives us the normal component of the vector
                normalComponent = normalComponentOfVector * surfaceNormal;

                // The vector plus the negative normalComponent will give us the tangential component in the reverse direction
                tangentialComponent = -(objectVelocity + (-normalComponent));
                */
            }
            else
            {
                // Object velocity is equal to zero so set both components to zero
                normalComponent = Vector3.Zero;
                tangentialComponent = Vector3.Zero;
            }
        }
        /// <summary>
        /// Sets the heightDifference parameter for this GameObject.
        /// HeightDifference is positive when object is below the terrain.
        /// </summary>
        /// <param name="terrain">Terrain object to determine height difference with.</param>
        public void GetObjectHeight(Terrain terrain)
        {
            // Used to calculate the average terrain height around the player
            localTerrainHeight = 0;

            // Error check
            mass.EnforceBoundary();

            // Get X and Z positions
            int posX = (int)mass.currentPosition.X;
            int posZ = (int)mass.currentPosition.Z;

            // Add up all neighboring terrain points
            localTerrainHeight = terrain.GetTerrainHeight(posX / Statics.TerrainSettings.terrainScaleFactor, posZ / Statics.TerrainSettings.terrainScaleFactor);
            surfaceNormal = terrain.GetTerrainNormal(posX / Statics.TerrainSettings.terrainScaleFactor, posZ / Statics.TerrainSettings.terrainScaleFactor, mass.velocity);

            // Average all the neighboring terrain points
            float newHeight = localTerrainHeight + (mass.objectHeight / 2);

            // Get difference between average and player
            heightDifference = newHeight - mass.currentPosition.Y;
        }

        /// <summary>
        /// Draws a stand alone model with no instancing or triangle stripping.
        /// Uses model stored in ModelManager and referenced by objectModelName.
        /// </summary>
        /// <param name="modelManager">ModelManager containing this object's model file.</param>
        /// <param name="technique">Shader technique to draw model with.</param>
        public virtual void Draw(ModelManager modelManager, string technique)
        {
            // Calculate ObjectSpace(Rotation) and WorldSpace(Translation) Transformation Matrix
            matrix = Matrix.CreateScale(mass.scale) *
                     Matrix.CreateFromQuaternion(mass.currentRotation) *
                     Matrix.CreateTranslation(mass.currentPosition);

            // Matricies
            ShaderParameters.World.SetValue(matrix);

            // Lighting
            ShaderParameters.shininess.SetValue(7000.0f);
         
            // Load resources for that catagory
            ModelInfo modelInfo = modelManager.GetModelInfo(objectModelName);
            ShaderParameters.modelTexture1.SetValue(modelInfo.currentTexture);
            ShaderParameters.bumpTexture1.SetValue(modelInfo.bumpTexture);

            foreach (ModelMesh mesh in modelInfo.model.Meshes)
            {
                Statics.SystemSettings.graphics.GraphicsDevice.Indices = mesh.IndexBuffer;

                foreach (ModelMeshPart part in mesh.MeshParts)
                {
                    Statics.SystemSettings.graphics.GraphicsDevice.VertexDeclaration = part.VertexDeclaration;
                    Statics.SystemSettings.graphics.GraphicsDevice.Vertices[0].SetSource(mesh.VertexBuffer, part.StreamOffset, part.VertexStride);

                    part.Effect.CurrentTechnique = part.Effect.Techniques[technique];
                    part.Effect.Begin();
                    for (int k = 0; k < part.Effect.CurrentTechnique.Passes.Count; k++)
                    {
                        EffectPass pass = part.Effect.CurrentTechnique.Passes[k];
                        pass.Begin();

                        Statics.SystemSettings.graphics.GraphicsDevice.DrawIndexedPrimitives(PrimitiveType.TriangleList,
                                                                                    part.BaseVertex,
                                                                                    0,
                                                                                    part.NumVertices,
                                                                                    part.StartIndex,
                                                                                    part.PrimitiveCount);
                        pass.End();
                    }
                    part.Effect.End();
                }
            }
        }

        /// <summary>
        /// Draws a stand alone model with no instancing or triangle stripping.
        /// Uses model passed in from invoking function call.
        /// </summary>
        /// <param name="model">Model to draw.</param>
        /// <param name="technique">Shader technique to draw model with.</param>
        public void DrawBasic(Model model, string technique)
        {
            // Calculate ObjectSpace(Rotation) and WorldSpace(Translation) Transformation Matrix
            matrix = Matrix.CreateScale(mass.scale) *
                     Matrix.CreateFromQuaternion(mass.currentRotation) *
                     Matrix.CreateTranslation(mass.currentPosition);

            // Matricies
            ShaderParameters.World.SetValue(matrix);

            // Lighting
            ShaderParameters.shininess.SetValue(7000.0f);

            foreach (ModelMesh mesh in model.Meshes)
            {
                Statics.SystemSettings.graphics.GraphicsDevice.Indices = mesh.IndexBuffer;

                foreach (ModelMeshPart part in mesh.MeshParts)
                {
                    Statics.SystemSettings.graphics.GraphicsDevice.VertexDeclaration = part.VertexDeclaration;
                    Statics.SystemSettings.graphics.GraphicsDevice.Vertices[0].SetSource(mesh.VertexBuffer, part.StreamOffset, part.VertexStride);

                    part.Effect.CurrentTechnique = part.Effect.Techniques[technique];
                    part.Effect.Begin();
                    for (int k = 0; k < part.Effect.CurrentTechnique.Passes.Count; k++)
                    {
                        EffectPass pass = part.Effect.CurrentTechnique.Passes[k];
                        pass.Begin();

                        Statics.SystemSettings.graphics.GraphicsDevice.DrawIndexedPrimitives(PrimitiveType.TriangleList,
                                                                                    part.BaseVertex,
                                                                                    0,
                                                                                    part.NumVertices,
                                                                                    part.StartIndex,
                                                                                    part.PrimitiveCount);
                        pass.End();
                    }
                    part.Effect.End();
                }
            }
        }

        /// <summary>
        /// Draws a stand alone model that uses the triangle-strip content processor for loading.
        /// </summary>
        /// <param name="model">Model to draw.</param>
        /// <param name="technique">Shader technique to draw model with.</param>
        public void DrawTriStrips(Model model, string technique)
        {
            foreach (ModelMesh mesh in model.Meshes)
            {
                Statics.SystemSettings.graphics.GraphicsDevice.Indices = mesh.IndexBuffer;

                foreach (ModelMeshPart part in mesh.MeshParts)
                {
                    part.Effect.CurrentTechnique = part.Effect.Techniques[technique];

                    Statics.SystemSettings.graphics.GraphicsDevice.VertexDeclaration = part.VertexDeclaration;
                    Statics.SystemSettings.graphics.GraphicsDevice.Vertices[0].SetSource(mesh.VertexBuffer, part.StreamOffset, part.VertexStride);

                    int numPrimitives;
                    if (mesh.IndexBuffer.IndexElementSize == IndexElementSize.SixteenBits)
                    {
                        numPrimitives = mesh.IndexBuffer.SizeInBytes / sizeof(ushort);
                    }
                    else
                    {
                        numPrimitives = mesh.IndexBuffer.SizeInBytes / sizeof(int);
                    }
                    numPrimitives -= 2;

                    part.Effect.Begin();
                    foreach (EffectPass pass in part.Effect.CurrentTechnique.Passes)
                    {
                        pass.Begin();

                        Statics.SystemSettings.graphics.GraphicsDevice.DrawIndexedPrimitives(PrimitiveType.TriangleStrip,
                                                                                    part.BaseVertex,
                                                                                    0,
                                                                                    part.NumVertices,
                                                                                    part.StartIndex,
                                                                                    numPrimitives);

                        pass.End();
                    }
                    part.Effect.End();
                }
            }
        }
        /// <summary>
        /// Draws an instanced model that uses the standard content processor.
        /// </summary>
        /// <param name="model">Model to draw.</param>
        /// <param name="technique">Shader technique to draw model with.</param>
        /// <param name="vertexStride">The number of bits between verticies. Use "vertexDeclaration.GetVertexStrideSize()" to find this.</param>
        public void DrawInstancedBasic(Model model, string technique, int vertexStride)
        {
            foreach (ModelMesh mesh in model.Meshes)
            {
                // Set the index buffer
                Statics.SystemSettings.graphics.GraphicsDevice.Indices = mesh.IndexBuffer;

                // Tell the GPU how many times to run through the vertex data and set the stream.
                Statics.SystemSettings.graphics.GraphicsDevice.Vertices[0].SetSource(mesh.VertexBuffer, 0, vertexStride);

                foreach (ModelMeshPart part in mesh.MeshParts)
                {
                    part.Effect.CurrentTechnique = part.Effect.Techniques[technique];
                    part.Effect.Begin();

                    for (int k = 0; k < part.Effect.CurrentTechnique.Passes.Count; k++)
                    {
                        EffectPass pass = part.Effect.CurrentTechnique.Passes[k];
                        pass.Begin();

                        Statics.SystemSettings.graphics.GraphicsDevice.DrawIndexedPrimitives(PrimitiveType.TriangleList,
                                                                                    part.BaseVertex,
                                                                                    0,
                                                                                    part.NumVertices,
                                                                                    part.StartIndex,
                                                                                    part.PrimitiveCount);
                        pass.End();
                    }
                    part.Effect.End();
                }
            }
        }
        /// <summary>
        /// Draws an instanced model that uses the triangle-strip content processor.
        /// </summary>
        /// <param name="model">Model to draw.</param>
        /// <param name="technique">Shader technique to draw model with.</param>
        /// <param name="vertexStride">The number of bits between verticies. Use "vertexDeclaration.GetVertexStrideSize()" to find this.</param>
        public void DrawInstancedTriStrips(Model model, string technique, int vertexStride)
        {
            foreach (ModelMesh mesh in model.Meshes)
            {
                // Set the index buffer
                Statics.SystemSettings.graphics.GraphicsDevice.Indices = mesh.IndexBuffer;

                int numPrimitives;
                if (mesh.IndexBuffer.IndexElementSize == IndexElementSize.SixteenBits)
                {
                    numPrimitives = mesh.IndexBuffer.SizeInBytes / sizeof(ushort);
                }
                else
                {
                    numPrimitives = mesh.IndexBuffer.SizeInBytes / sizeof(int);
                }
                numPrimitives -= 2;

                // Tell the GPU how many times to run through the vertex data and set the stream.
                Statics.SystemSettings.graphics.GraphicsDevice.Vertices[0].SetSource(mesh.VertexBuffer, 0, vertexStride);

                foreach (ModelMeshPart part in mesh.MeshParts)
                {
                    part.Effect.CurrentTechnique = part.Effect.Techniques[technique];
                    part.Effect.Begin();

                    for (int k = 0; k < part.Effect.CurrentTechnique.Passes.Count; k++)
                    {
                        EffectPass pass = part.Effect.CurrentTechnique.Passes[k];
                        pass.Begin();

                        Statics.SystemSettings.graphics.GraphicsDevice.DrawIndexedPrimitives(PrimitiveType.TriangleStrip,
                                                                                    part.BaseVertex,
                                                                                    0,
                                                                                    part.NumVertices,
                                                                                    part.StartIndex,
                                                                                    numPrimitives);
                        pass.End();
                    }
                    part.Effect.End();
                }
            }
        }

        /// <summary>
        /// Called after Draw method.
        /// Allows GameObjects to add Billboards to be drawn.
        /// List is cleared each pass, or frame.
        /// </summary>
        /// <param name="objectLibrary">ObjectLibrary that this object belongs to.</param>
        /// <param name="gameObjectBillboards">Dynamic Billboard list.</param>
        public virtual void Draw_Billboards(ObjectLibrary objectLibrary, BillboardList gameObjectBillboards)
        { 
            //do stuff later 
        }
        #endregion
    }
}

#region Legacy Code - Heat dissipation and State Change
/* Legacy Code
        // Test Function to update energy distribution
        public void UpdateHeatDissipation(ObjectLibrary objectLibrary, float dt)
        {
            List<Particle> newParticlesToAddToList = new List<Particle>();

            foreach (Particle particle in particles)
            {
                particle.mass.UpdatePosition(dt);
            }

            // Iterate through dynamic particles
            for (int i = 0; i < particles.Count; i++)
            {
                Particle particle = particles[i];

                // List to store the pointers to neighboring particles
                List<Particle> neighboringParticleList = new List<Particle>();

                // Used to calculate the average value of all neighboring particles
                float averageEnergy = particle.mass.energy;

                // Get the list of neighboring particle pointers
                neighboringParticleList = GetSurroundingParticles(particle.mass.currentPosition, objectLibrary);

                // Calculate their total energy
                foreach (Particle neigborParticle in neighboringParticleList)
                {
                    averageEnergy += neigborParticle.mass.energy;
                }

                // Find the average
                averageEnergy /= neighboringParticleList.Count + 1;

                // If the average value is not equal to zero then we have some heat dissipation to do
                if (averageEnergy != particle.mass.energy && neighboringParticleList.Count != 0)
                {
                    // Iterate through neighboring particles
                    foreach (Particle neigborParticle in neighboringParticleList)
                    {
                        // If their value is not equal to the average set it and set the flag
                        if (neigborParticle.mass.energy != averageEnergy)
                        {
                            neigborParticle.mass.SetEnergy(averageEnergy);

                            if (!neigborParticle.mass.isChanging)
                            {
                                neigborParticle.mass.isChanging = true;
                                newParticlesToAddToList.Add(neigborParticle);
                            }
                        }
                    }

                    // Set the starting particle's energy to average value as well
                    particle.mass.SetEnergy(averageEnergy);
                }
                else if (particle.mass.energy != 0.0f)
                {
                    DissipateHeat(particle);
                }
                else
                {
                    // The particle and it's neighbors are in equilibrium so remove it from the list
                    particle.mass.isChanging = false;
                    if (!particle.mass.isMoving)
                    {
                        // Particle needs to be put back into the static list
                        MoveParticle(particles, particles, particle);
                    }
                    else
                    {
                        particles.Remove(particle);
                    }

                    i--;
                }
            }

            foreach (Particle newParticle in newParticlesToAddToList)
            {
                if (particles.Contains(newParticle))
                {
                    continue;
                }

                if (newParticle.mass.isMoving)
                {
                    CopyParticle(particles, particles, newParticle);
                }
                else
                {
                    MoveParticle(particles, particles, newParticle);
                }
            }
        }
        
        public void StateChange(ObjectLibrary objectLibrary, float elementUse, GameObject gameObject)
        {
            Particle particle = (Particle)gameObject;

            gameObject.mass.ChangeEnergy(elementUse / 2.0f);

            if (gameObject.mass.isChanging)
            {
                return;
            }
            else if (gameObject.mass.isMoving)
            {
                // Particle is in the dynamic list so we need to copy it to the Thermal list
                switch (particle.particleType)
                {
                    case Particle.ParticleType.Air:
                        {
                            objectLibrary.particleManager.air.CopyParticle(objectLibrary.particleManager.air.dynamicParticles,
                                                                             objectLibrary.particleManager.air.thermalParticles,
                                                                             particle);
                            break;
                        }
                    case Particle.ParticleType.Water:
                        {
                            objectLibrary.particleManager.water.CopyParticle(objectLibrary.particleManager.water.dynamicParticles,
                                                                                objectLibrary.particleManager.water.thermalParticles,
                                                                                particle);
                            break;
                        }
                    case Particle.ParticleType.Earth:
                        {
                            objectLibrary.particleManager.earth.CopyParticle(objectLibrary.particleManager.earth.dynamicParticles,
                                                                               objectLibrary.particleManager.earth.thermalParticles,
                                                                               particle);
                            break;
                        }
                }
                gameObject.mass.isChanging = true;
            }
            else
            {
                // It's in the static list, so move the particle to the dynamic list
                switch (particle.particleType)
                {
                    case Particle.ParticleType.Air:
                        {
                            objectLibrary.particleManager.air.MoveParticle(objectLibrary.particleManager.air.staticParticles,
                                                                             objectLibrary.particleManager.air.thermalParticles,
                                                                             particle);
                            break;
                        }
                    case Particle.ParticleType.Water:
                        {
                            objectLibrary.particleManager.water.MoveParticle(objectLibrary.particleManager.water.staticParticles,
                                                                                objectLibrary.particleManager.water.thermalParticles,
                                                                                particle);
                            break;
                        }
                    case Particle.ParticleType.Earth:
                        {
                            objectLibrary.particleManager.earth.MoveParticle(objectLibrary.particleManager.earth.staticParticles,
                                                                               objectLibrary.particleManager.earth.thermalParticles,
                                                                               particle);
                            break;
                        }
                }
                gameObject.mass.isChanging = true;
            }
        }
*/
#endregion