using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;

namespace Kav
{
    public class SimpleDepthEffect : Effect, IHasWorldMatrix
    {
        EffectParameter worldParam;
        EffectParameter viewProjectionParam;
        EffectParameter vertexShaderIndexParam;

        Matrix world;
        Matrix view;
        Matrix projection;
        bool hardwareInstancingEnabled = false;

        EffectDirtyFlags dirtyFlags = EffectDirtyFlags.All;

        public Matrix World
        {
            get { return world; }
            set
            {
                world = value;
                dirtyFlags |= EffectDirtyFlags.World;
            }
        }

        public Matrix View
        {
            get { return view; }
            set
            {
                view = value;
                dirtyFlags |= EffectDirtyFlags.ViewProj;
            }
        }

        public Matrix Projection
        {
            get { return projection; }
            set
            {
                projection = value;
                dirtyFlags |= EffectDirtyFlags.ViewProj;
            }
        }

        public bool HardwareInstancingEnabled
        {
            get { return hardwareInstancingEnabled; }
            set
            {
                if (value != hardwareInstancingEnabled)
                {
                    hardwareInstancingEnabled = value;
                    dirtyFlags |= EffectDirtyFlags.VertexShaderIndex;
                }
            }
        }

        public SimpleDepthEffect(GraphicsDevice graphicsDevice) : base(graphicsDevice, Resources.SimpleDepthEffect)
        {
            CacheEffectParameters();
        }

        protected override void OnApply()
        {
            if ((dirtyFlags & EffectDirtyFlags.World) != 0)
            {
                worldParam.SetValue(world);

                dirtyFlags &= ~EffectDirtyFlags.World;
            }

            if ((dirtyFlags & EffectDirtyFlags.ViewProj) != 0)
            {
                Matrix.Multiply(ref view, ref projection, out Matrix viewProjection);
                viewProjectionParam.SetValue(viewProjection);

                dirtyFlags &= ~EffectDirtyFlags.ViewProj;
            }

            if ((dirtyFlags & EffectDirtyFlags.VertexShaderIndex) != 0)
            {
                int vertexShaderIndex = 0;

                if (hardwareInstancingEnabled)
                {
                    vertexShaderIndex = 1;
                }

                vertexShaderIndexParam.SetValue(vertexShaderIndex);
            }
        }

        private void CacheEffectParameters()
        {
            worldParam = Parameters["World"];
            viewProjectionParam = Parameters["ViewProjection"];
            vertexShaderIndexParam = Parameters["VertexShaderIndex"];
        }
    }
}