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

namespace DarkWynter.Stream
{
    #region Using Statements
    using System;
    using System.Collections.Generic;
    using Microsoft.Xna.Framework;
    using Microsoft.Xna.Framework.Graphics;
    using System.Xml;
    using System.ComponentModel;
    #endregion

    /// <summary>
    /// Vertex data containing Position and Normal info
    /// </summary>
    public struct VertexPositionNormal
    {
        /// <summary>
        /// Position
        /// </summary>
        public Vector3 Position;
        /// <summary>
        /// Normal
        /// </summary>
        public Vector3 Normal;
    }

    /// <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
    /// Depth       = World.M41, World.M42, World.M43, World.M44
    /// </summary>
    public struct VertexFogBinormalTangentDepth
    {
        /// <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 Depth;
    }

    /// <summary>
    /// Stores all the draw function calls for game objects
    /// </summary>
    public class Draw
    {
        /// <summary>
        /// Usage of the draw object
        /// </summary>
        public enum DrawMethod : byte
        {

            /// <summary>
            /// Basic game object draw method
            /// </summary>
            BasicGameObject_Draw,
 
            /// <summary>
            /// Draw GPU object list
            /// </summary>
            GPUObjectList_Draw

        };
        /// <summary>
        /// Model used by this GameObject.
        /// </summary>
        public Model model { get { return _model; } set { _model = value; } }
        private Model _model;
        /// <summary>
        /// Location and orientation matrix passed to shaders.
        /// </summary>
        public Matrix matrix { get { return _matrix; } set { _matrix = value; } }
        private Matrix _matrix;
        /// <summary>
        /// Textures associated with this object.
        /// </summary>
        public List<Texture2D> textureList { get { return _textureList; } set { _textureList = value; } }
        private List<Texture2D> _textureList = new List<Texture2D>();
        /// <summary>
        /// Needed to fix the rotation caused to animated models
        /// </summary>
        public Matrix initialTransform { get { return _initialTransform; } set { _initialTransform = value; } }
        private Matrix _initialTransform = Matrix.Identity;

        /// <summary>
        /// Buffer to store vertices
        /// </summary>
        public VertexBuffer vertexBuffer { get { return _vertexBuffer; } set { _vertexBuffer = value; } }
        private VertexBuffer _vertexBuffer;
        /// <summary>
        /// Vertex Declaration.
        /// </summary>
        public VertexDeclaration vertexDeclaration { get { return _vertexDeclaration; } set { _vertexDeclaration = value; } }
        private VertexDeclaration _vertexDeclaration;
        /// <summary>
        /// Instance data (Fog, Binormal, Tangent, Depth)
        /// Used for GameObject instancing
        /// </summary>
        public VertexFogBinormalTangentDepth[] instanceDataFBTD { get { return _instanceDataFBTD; } set { _instanceDataFBTD = value; } }
        private VertexFogBinormalTangentDepth[] _instanceDataFBTD;
        /// <summary>
        /// Usage of the draw object
        /// </summary>
        public DrawMethod drawMethod { get { return _drawMethod; } set { _drawMethod = value; } }
        private DrawMethod _drawMethod;
        /// <summary>
        /// Shader technique to use
        /// </summary>
        public string technique { get { return _technique; } set { _technique = value; } }
        private string _technique;

        #region Stream formats for instancing
        /// <summary>
        /// Tells the GPU how to format the streams for instancing
        /// Uses the Fog, Binormal, Tangent and Depth fields of the stream
        /// </summary>
        public VertexElement[] FBTDElements = new VertexElement[]
        {
            new VertexElement(0, 0, VertexElementFormat.Vector3, VertexElementMethod.Default, VertexElementUsage.Position,  0),
            new VertexElement(0, sizeof(float) * 3, VertexElementFormat.Vector3, VertexElementMethod.Default, VertexElementUsage.Normal,  0),
            new VertexElement(0, sizeof(float) * 6, VertexElementFormat.Vector2, VertexElementMethod.Default, VertexElementUsage.TextureCoordinate, 0),
            new VertexElement(1, 0, VertexElementFormat.Vector4, VertexElementMethod.Default, VertexElementUsage.TextureCoordinate, 1),
            new VertexElement(1, sizeof(float) * 4, VertexElementFormat.Vector4, VertexElementMethod.Default, VertexElementUsage.TextureCoordinate, 2),
            new VertexElement(1, sizeof(float) * 8, VertexElementFormat.Vector4, VertexElementMethod.Default, VertexElementUsage.TextureCoordinate, 3),
            new VertexElement(1, sizeof(float) * 12, VertexElementFormat.Vector4, VertexElementMethod.Default, VertexElementUsage.TextureCoordinate, 4),
        };

        /// <summary>
        /// Tells the GPU how to format the streams for instancing
        /// Used for instanced animation
        /// </summary>
        public VertexElement[] InstAnimElements = new VertexElement[]
        {
            new VertexElement(0, 0, VertexElementFormat.Vector3, VertexElementMethod.Default, VertexElementUsage.Position,  0),
            new VertexElement(0, sizeof(float) * 3, VertexElementFormat.Vector3, VertexElementMethod.Default, VertexElementUsage.Normal,  0),
            new VertexElement(0, sizeof(float) * 6, VertexElementFormat.Vector2, VertexElementMethod.Default, VertexElementUsage.TextureCoordinate, 0),
            new VertexElement(0, sizeof(float) * 8, VertexElementFormat.Byte4, VertexElementMethod.Default, VertexElementUsage.BlendIndices, 0),
            new VertexElement(0, sizeof(float) * 9, VertexElementFormat.Color, VertexElementMethod.Default, VertexElementUsage.BlendWeight, 0),
            new VertexElement(1, 0, VertexElementFormat.Vector4, VertexElementMethod.Default, VertexElementUsage.TextureCoordinate, 1),
            new VertexElement(1, sizeof(float) * 4, VertexElementFormat.Vector4, VertexElementMethod.Default, VertexElementUsage.TextureCoordinate, 2),
            new VertexElement(1, sizeof(float) * 8, VertexElementFormat.Vector4, VertexElementMethod.Default, VertexElementUsage.TextureCoordinate, 3),
            new VertexElement(1, sizeof(float) * 12, VertexElementFormat.Vector4, VertexElementMethod.Default, VertexElementUsage.TextureCoordinate, 4),
        };
        #endregion

        /// <summary>
        /// Constructor
        /// </summary>
        public Draw()
        {
        }


        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="method">The draw method to use</param>
        /// <param name="drawTechnique">Technique to use</param>
        public Draw(DrawMethod method, string drawTechnique)
        {
            drawMethod = method;
            technique = drawTechnique;
        }

        /// <summary>
        /// Base draw function which calls the required functions depending on the draw method of this object
        /// </summary>
        public void DoDraw(GraphicsDevice gd)
        {
            switch (drawMethod)
            {
                case DrawMethod.BasicGameObject_Draw:
                    {
                        DrawBasicGO(gd);
                        break;
                    }
                case DrawMethod.GPUObjectList_Draw:
                    {
                        DrawGPUObjectList(gd);
                        break;
                    }
            }
        }



        private void DrawBasicGO(GraphicsDevice gd)
        {
            //ShaderParameters.DrawFX.World.SetValue(matrix);

            //ShaderParameters.DrawFX.modelTexture1.SetValue(textureList[0]);
            //ShaderParameters.DrawFX.bumpTexture1.SetValue(textureList[1]);

            // Draw the model
            TriStrips(gd);
        }


        private void DrawGPUObjectList(GraphicsDevice gd)
        {
            //ShaderParameters.DrawFX.modelTexture1.SetValue(textureList[0]);
            //ShaderParameters.DrawFX.bumpTexture1.SetValue(textureList[1]);
            
            // Set the vertex declaration
            gd.VertexDeclaration = vertexDeclaration;
            gd.Vertices[0].SetFrequencyOfIndexData(instanceDataFBTD.Length);

            // Tell GPU how many times to run through the instance data and set the stream.
            gd.Vertices[1].SetSource(vertexBuffer, 0, gd.VertexDeclaration.GetVertexStrideSize(1));
            gd.Vertices[1].SetFrequencyOfInstanceData(1);

            // Draw the model
            InstancedTriStrips(gd);
        }




        /// <summary>
        /// Draws a stand alone model with no instancing or triangle stripping.
        /// </summary>
        private void TriList(GraphicsDevice gd)
        {
            foreach (ModelMesh mesh in model.Meshes)
            {
                gd.Indices = mesh.IndexBuffer;

                foreach (ModelMeshPart part in mesh.MeshParts)
                {
                    gd.VertexDeclaration = part.VertexDeclaration;
                    gd.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();

                        gd.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>
        private void TriStrips(GraphicsDevice gd)
        {
            foreach (ModelMesh mesh in model.Meshes)
            {
                gd.Indices = mesh.IndexBuffer;

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

                    gd.VertexDeclaration = part.VertexDeclaration;
                    gd.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();

                        gd.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>
        private void InstancedTriList(GraphicsDevice gd)
        {
            foreach (ModelMesh mesh in model.Meshes)
            {
                // Set the index buffer
                gd.Indices = mesh.IndexBuffer;

                // Tell the GPU how many times to run through the vertex data and set the stream.
                gd.Vertices[0].SetSource(mesh.VertexBuffer, 0, gd.VertexDeclaration.GetVertexStrideSize(0));

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

                        gd.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>
        private void InstancedTriStrips(GraphicsDevice gd)
        {
            foreach (ModelMesh mesh in model.Meshes)
            {
                // Set the index buffer
                gd.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.
                gd.Vertices[0].SetSource(mesh.VertexBuffer, 0, gd.VertexDeclaration.GetVertexStrideSize(0));

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

                        //gd.RenderState.FillMode = Stream.Statics_Stream.RenderSettings.fillMode;

                        gd.DrawIndexedPrimitives(PrimitiveType.TriangleStrip,
                                                 part.BaseVertex,
                                                 0,
                                                 part.NumVertices,
                                                 part.StartIndex,
                                                 numPrimitives);
                        pass.End();
                    }
                    part.Effect.End();
                }
            }
        }

    }
}