//---------------------------------------------------------------------------------------------------------------------------------------------------
// <copyright file="Prop.cs" company="DarkWynter Studios">
//     Copyright (C)2007 DarkWynter Studios.  All rights reserved.
// </copyright>
//---------------------------------------------------------------------------------------------------------------------------------------------------
// {License Information: Creative Commons}
//---------------------------------------------------------------------------------------------------------------------------------------------------

namespace ElementalGame
{
    #region Using Statements
    using System;
    using System.Collections.Generic;
    using Microsoft.Xna.Framework;
    using Microsoft.Xna.Framework.Audio;
    using Microsoft.Xna.Framework.Content;
    using Microsoft.Xna.Framework.Graphics;
    using Microsoft.Xna.Framework.Input;
    using Microsoft.Xna.Framework.Storage;
    using System.Xml;
    #endregion

    public class Prop : GameObject
    {
        public Prop(Mass darkMass)
        {
            mass = darkMass;
            mass.COR = 0.99999f;
        }

        /* GameObject Interface Methods
         *   
         */

        public override void Load(XmlNode node)
        {
            base.Load(node);

            if (objectModelName == "object")
            {
                mass.mass = 10;
                _boundingSphere.Radius = 10.0f * mass.scale;
            }

            if (objectModelName.Contains("tree"))
            {
                _boundingSphere.Radius = mass.scale;
            }

            if (objectModelName.Contains("rock"))
            {
                _boundingSphere.Radius = mass.scale / 10.0f;
            }

            _boundingSphere.Center = mass.currentPosition + new Vector3(0.0f, mass.scale / 2.0f, 0.0f);
            mass.dynamicFrictionCoefficient = 0.0f;
            mass.isMoving = true;
            mass.objectType = Mass.ObjectType.PROP;
            mass.objectHeight = 5;

            // Load Effect
            effect = ElementalGame.content.Load<Effect>("Shaders/ElementalGPU");
        }

        public override void Update(ObjectLibrary objectLibrary)
        {
            mass.UpdatePosition();
            _boundingSphere.Center = mass.currentPosition;

            objectValues = new VertexFogBinormalTangentWeightTess();

            matrix = Matrix.CreateScale(mass.scale) *
                     Matrix.CreateFromQuaternion(mass.currentRotation) *
                     Matrix.CreateTranslation(mass.currentPosition);

            objectValues.Fog = new Vector4(matrix.M11, matrix.M12, matrix.M13, matrix.M14);             // Store the first row
            objectValues.Binormal = new Vector4(matrix.M21, matrix.M22, matrix.M23, matrix.M24);        // Store the second row
            objectValues.Tangent = new Vector4(matrix.M31, matrix.M32, matrix.M33, matrix.M34);         // Store the third row
            objectValues.BlendWeight = new Vector4(matrix.M41, matrix.M42, matrix.M43, matrix.M44);     // Store the fourth row
        }

        public override void DrawShadow(ModelManager modelManager)
        {
            ModelInfo modelInfo = new ModelInfo();
      

            // Calculate ObjectSpace(Rotation) and WorldSpace(Translation) Transformation Matrix
            matrix = Matrix.CreateScale(mass.scale) *
                     Matrix.CreateFromQuaternion(mass.currentRotation) *
                     Matrix.CreateTranslation(mass.currentPosition);

            modelInfo = modelManager.GetModelInfo(objectModelName);

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

            // Draw the model
            foreach (ModelMesh mesh in modelInfo.model.Meshes)
            {
                foreach (Effect currentEffect in mesh.Effects)
                {
                    currentEffect.CurrentTechnique = currentEffect.Techniques["ShadowMap"];
                }
                mesh.Draw();
            }
        }

        public override void Draw(ModelManager modelManager)
        {
            ModelInfo modelInfo = new ModelInfo();

            // 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);

            modelInfo = modelManager.GetModelInfo(objectModelName);

            // Lighting
            ShaderParameters.coreShininess.SetValue(7000.0f);
            ShaderParameters.coreMaterialDiffuse.SetValue(modelInfo.materialDiffuse);
            ShaderParameters.coreMaterialSpecular.SetValue(modelInfo.materialSpecular);

            // Load resources for that catagory
            ShaderParameters.modelTexture1.SetValue(modelInfo.currentTexture);
            ShaderParameters.bumpTexture1.SetValue(modelInfo.bumpTexture);

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

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

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

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

        }
    }
}