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

namespace DarkWynter.Stream.PhysicsGpu
{
    #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

    /// <summary>
    /// GpuVariable is basic data structure used in gpu processing.
    /// Generally, it will contain a texture in which each pixel represents a single property from an object.
    /// This system aggregates variables of like type into a single texture...  eg- one texture holds all velocity variables across multiple objects.
    /// This texture is then processed using a simple shader that acts uniformly across all pixels, making for a RISC approach to gpu processing.
    /// </summary>
    public class GpuVariable : GpuVariableInterface
    {
        #region Interfacing
        /// <summary>
        /// Texture used by Gpu to read values in.
        /// Swapped with write texture each pass.
        /// </summary>
        public Texture2D _read { get { return read; } set { read = value; } }
        /// <summary>
        /// Texture used by Gpu to write values out.
        /// Swapped with read texture each pass.
        /// </summary>
        public Texture2D _write { get { return write; } set { write = value; } }
        /// <summary>
        /// Gpu handle that sets either the read texture each pass after it is swapped with the write texture.
        /// </summary>
        public EffectParameter _gpuPointer { get { return gpuPointer; } set { gpuPointer = value; } }
        /// <summary>
        /// A render target for the write texture.
        /// </summary>
        public RenderTarget2D _writeRenderTarget { get { return writeRenderTarget; } set { writeRenderTarget = value; } }
        /// <summary>
        /// A render target for the read texture.
        /// </summary>
        public RenderTarget2D _readRenderTarget { get { return readRenderTarget; } set { readRenderTarget = value; } }
        
        /// <summary>
        /// Needed in case the game window resolution is less than the spatial map resolution.
        /// If this is the case, the original depth buffer used with the game window also needs to be swapped when we run
        /// our update pass
        /// </summary>
        public DepthStencilBuffer _depthBuff { get { return depthBuff; } set { depthBuff = value; } }
        #endregion

        #region Standard Variables
        private Texture2D read;
        private Texture2D write;
        private Texture2D swapTexture;

        private RenderTarget2D writeRenderTarget;
        private RenderTarget2D readRenderTarget;
        private DepthStencilBuffer depthBuff;
        private RenderTarget2D swapTarget;
        #endregion

        // Vector4 array holds properties that we pass to gpu texture
        Vector4[] texValues;
        int texIndex;
        int maxCount;

        /// <summary>
        /// Shader technique (aka- program) to use with this variable.
        /// </summary>
        public string technique;
        private EffectParameter gpuPointer;

        /// <summary>
        /// Shader variable associated with this GpuVariable.
        /// </summary>
        public string gpuParamName;
        private string outTexName;
        /// <summary>
        /// Minimum numerical value of data being added to this texture.
        /// </summary>
        public float minimumValue;
        /// <summary>
        /// Range of numerical data being added to this texture.
        /// </summary>
        public float scaleRange;
        /// <summary>
        /// Data being added to this texture.
        /// </summary>
        public List<Vector4> properties = new List<Vector4>();

        /// <summary>
        /// Tells GpuProcessor to execute this GpuVariable using either Quad or Quad of Points processing.
        /// </summary>
        public Enums_Stream.GpuProcessorMode processorMode;
        /// <summary>
        /// Tells GpuProcessor whether it should update this GpuVariable.
        /// </summary>
        public bool isDynamic;

        /// <summary>
        /// GpuVariable constructor.
        /// </summary>
        public GpuVariable()
        {
            // Empty Constructor
        }

        /// <summary>
        /// Creates a structure for executing a single pass on the shader hardware.
        /// Each GpuVariable contains a multiple instances of the same data.
        /// Eg - velocity
        /// </summary>
        /// <param name="shadeTechnique">Technique to use. </param>
        /// <param name="gpuParameterPointer">The Effect Parameter for this variable. </param>
        /// <param name="ProcessorMode">Process using Spatial or Indexed processing technique. </param>
        /// <param name="Update">Update this Variable each frame. </param>
        /// <param name="minValue">Minimum value of data added using AddProperty methods.</param>
        /// <param name="maxValue">Maximum value of data added using AddProperty methods.</param>
        public GpuVariable(string shadeTechnique, EffectParameter gpuParameterPointer,
            Enums_Stream.GpuProcessorMode ProcessorMode, bool Update, float minValue, float maxValue)
        {
            // Store info
            technique = shadeTechnique;
            outTexName = shadeTechnique;
            processorMode = ProcessorMode;
            isDynamic = Update;

            GraphicsDevice gd = Statics_Stream.RenderSettings.graphics.GraphicsDevice;

            if (ProcessorMode == Enums_Stream.GpuProcessorMode.Indexed)
            {
                // Create Render Targets
                writeRenderTarget = new RenderTarget2D(gd, Statics_Stream.GPU_ProcessorSettings.INDEXED_TARGET_SIZE, Statics_Stream.GPU_ProcessorSettings.INDEXED_TARGET_SIZE, 1, SurfaceFormat.Vector4);
                readRenderTarget = new RenderTarget2D(gd, Statics_Stream.GPU_ProcessorSettings.INDEXED_TARGET_SIZE, Statics_Stream.GPU_ProcessorSettings.INDEXED_TARGET_SIZE, 1, SurfaceFormat.Vector4);
                depthBuff = new DepthStencilBuffer(gd, Statics_Stream.GPU_ProcessorSettings.INDEXED_TARGET_SIZE, Statics_Stream.GPU_ProcessorSettings.INDEXED_TARGET_SIZE, DepthFormat.Depth24);
                texValues = new Vector4[Statics_Stream.GPU_ProcessorSettings.INDEXED_TARGET_SIZE * Statics_Stream.GPU_ProcessorSettings.INDEXED_TARGET_SIZE];
                maxCount = Statics_Stream.GPU_ProcessorSettings.INDEXED_TARGET_SIZE * Statics_Stream.GPU_ProcessorSettings.INDEXED_TARGET_SIZE;
            }
            else if (ProcessorMode == Enums_Stream.GpuProcessorMode.Spatial)
            {
                // Create Render Targets
                writeRenderTarget = new RenderTarget2D(gd, Statics_Stream.GPU_ProcessorSettings.SPATIAL_TARGET_SIZE, Statics_Stream.GPU_ProcessorSettings.SPATIAL_TARGET_SIZE, 1, SurfaceFormat.Vector4);
                readRenderTarget = new RenderTarget2D(gd, Statics_Stream.GPU_ProcessorSettings.SPATIAL_TARGET_SIZE, Statics_Stream.GPU_ProcessorSettings.SPATIAL_TARGET_SIZE, 1, SurfaceFormat.Vector4);
                depthBuff = new DepthStencilBuffer(gd, Statics_Stream.GPU_ProcessorSettings.SPATIAL_TARGET_SIZE, Statics_Stream.GPU_ProcessorSettings.SPATIAL_TARGET_SIZE, DepthFormat.Depth24);
                texValues = new Vector4[Statics_Stream.GPU_ProcessorSettings.SPATIAL_TARGET_SIZE * Statics_Stream.GPU_ProcessorSettings.SPATIAL_TARGET_SIZE];
                maxCount = Statics_Stream.GPU_ProcessorSettings.SPATIAL_TARGET_SIZE * Statics_Stream.GPU_ProcessorSettings.SPATIAL_TARGET_SIZE;
            }

            texIndex = 0;

            DepthStencilBuffer temp = gd.DepthStencilBuffer;

            // Clear out textures
            gd.SetRenderTarget(0, readRenderTarget);
            gd.DepthStencilBuffer = depthBuff;
            gd.Clear(ClearOptions.Target, Color.TransparentBlack, 1.0f, 0);
            gd.SetRenderTarget(0, null);
            read = readRenderTarget.GetTexture();

            gd.SetRenderTarget(0, writeRenderTarget);
            gd.Clear(ClearOptions.Target, Color.TransparentBlack, 1.0f, 0);
            gd.SetRenderTarget(0, null);
            write = writeRenderTarget.GetTexture();

            gd.DepthStencilBuffer = temp;
            // Turn off RTT

            // Set pointer to shader variable
            gpuPointer = gpuParameterPointer;

            // Save the min value for decompression
            minimumValue = minValue;

            // Get the data range
            if (minimumValue < 0.0f)
            {
                scaleRange = maxValue;
            }
            else
            {
                scaleRange = maxValue - minimumValue;
            }
        }

        #region Add Property
        /// <summary>
        /// Add a single property to the GpuVariable, before setting texture data.
        /// </summary>
        /// <param name="value">A value to add to the texture.</param>
        public virtual void AddProperty(float value)
        {
            properties.Add(new Vector4(value, scaleRange, scaleRange, scaleRange));
        }
        /// <summary>
        /// Add a single property to the GpuVariable, before setting texture data.
        /// </summary>
        /// <param name="value">A value to add to the texture.</param>
        public virtual void AddProperty(Vector2 value)
        {
            properties.Add(new Vector4(value.X, value.Y, scaleRange, scaleRange));
        }
        /// <summary>
        /// Add a single property to the GpuVariable, before setting texture data.
        /// </summary>
        /// <param name="value">A value to add to the texture.</param>
        public virtual void AddProperty(Vector3 value)
        {
            properties.Add(new Vector4(value.X, value.Y, value.Z, scaleRange));
        }
        /// <summary>
        /// Add a single property to the GpuVariable, before setting texture data.
        /// </summary>
        /// <param name="value">A value to add to the texture.</param>
        public virtual void AddProperty(Vector4 value)
        {
            properties.Add(new Vector4(value.X, value.Y, value.Z, value.W));
        }
        /// <summary>
        /// Add a single property to the GpuVariable, before setting texture data.
        /// </summary>
        /// <param name="value">A value to add to the texture.</param>
        public virtual void AddProperty(Quaternion value)
        {
            properties.Add(new Vector4(value.X, value.Y, value.Z, value.W));
        }
        #endregion

        #region Clear Property
        /// <summary>
        /// Removes a value from the property list at specified index.
        /// </summary>
        /// <param name="value">Index at which to remove property.</param>
        public virtual void ClearProperty(int value)
        {
            properties[value] = new Vector4(-scaleRange);
        }
        #endregion

        /// <summary>
        /// Set the texture with all added properties.
        /// Scales values based on minValue and maxValue, to between 0-1.
        /// </summary>
        public virtual void SetTexData()
        {
            // Copy values from properties to texture
            for (int i = 0; i < properties.Count; i++)
            {
                texValues[i].X = (properties[i].X ) / scaleRange;
                texValues[i].Y = (properties[i].Y ) / scaleRange;
                texValues[i].Z = (properties[i].Z ) / scaleRange;
                texValues[i].W = (properties[i].W ) / scaleRange;
            }

            texIndex = properties.Count;

            // Initialize both textures with values
            read.SetData<Vector4>(texValues);
            write.SetData<Vector4>(texValues);
            gpuPointer.SetValue(read);
        }
        /// <summary>
        /// Adds a property to texture while it is in use.
        /// Used by attack methods.
        /// </summary>
        /// <param name="startIndex">Location in properties list to begin adding data to texture.</param>
        /// <param name="count">Number of properties to add from list.</param>
        public virtual void SetSubTexData(int startIndex, int count)
        {
            for (int i = startIndex; i < startIndex + count; i++)
            {
                if (texIndex >= maxCount)
                {
                    // Restart from top of texture
                    texIndex = 0;
                }
                texValues[texIndex].X = (properties[i].X ) / scaleRange;
                texValues[texIndex].Y = (properties[i].Y ) / scaleRange;
                texValues[texIndex].Z = (properties[i].Z ) / scaleRange;
                texValues[texIndex].W = (properties[i].W ) / scaleRange;

                Rectangle rect = new Rectangle(texIndex % 256, (int)texIndex / 256, 1, 1);

                read.SetData<Vector4>(0, rect, texValues, texIndex, 1, SetDataOptions.Discard);
                write.SetData<Vector4>(0, rect, texValues, texIndex, 1, SetDataOptions.Discard);

                texIndex++;
            }

            gpuPointer.SetValue(read);
        }

        /// <summary>
        /// Unscale the data coming out of the texture to it's original scale.
        /// </summary>
        public virtual void UnScale()
        {
            // Vector4 array holds properties that we pass to gpu texture
            Vector4[] texValues = new Vector4[Statics_Stream.GPU_ProcessorSettings.INDEXED_TARGET_SIZE * Statics_Stream.GPU_ProcessorSettings.INDEXED_TARGET_SIZE];
            write.GetData<Vector4>(texValues);

            // Copy values from properties to texture
            for (int i = 0; i < properties.Count; i++)
            {
                properties[i] = (texValues[i] * scaleRange);
            }
        }
        /// <summary>
        /// Swap the read and write textures.
        /// This is required b/c the gpu does not guarentee that we can read and write to the same texture in the same pass.
        /// </summary>
        public void SwapBuffers()
        {
            // Swap the textures
            swapTexture = read;
            read = write;
            write = swapTexture;

            // Swap the render targets
            swapTarget = readRenderTarget;
            readRenderTarget = writeRenderTarget;
            writeRenderTarget = swapTarget;

            // Reset GPU Variable
            gpuPointer.SetValue(read);
        }
        /// <summary>
        /// Debug function that writes the read and write textures to files named using the outTexName value.
        /// </summary>
        public void WriteToFile()
        {
            write.Save(outTexName + "_Write.dds", ImageFileFormat.Dds);
            read.Save(outTexName + "_Read.dds", ImageFileFormat.Dds);
        }
    }
}