+ plugins project

10 files changed, 693 insertions, 0 deletions

diff --git a/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/DefaultEffect.cs b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/DefaultEffect.cs
new file mode 100644
index 0000000..df71e47
--- /dev/null
+++ b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/DefaultEffect.cs
@@ -0,0 +1,203 @@
+using System.Collections.Specialized;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+
+namespace MonoGame.Extended.Graphics.Effects
+{
+    /// <summary>
+    ///     An <see cref="Effect" /> that allows objects, within a 3D context, to be represented on a 2D monitor.
+    /// </summary>
+    /// <seealso cref="MatrixChainEffect" />
+    /// <seealso cref="ITextureEffect" />
+    public class DefaultEffect : MatrixChainEffect, ITextureEffect
+    {
+        /// <summary>
+        ///     The bitmask for use with <see cref="MatrixChainEffect.Flags" /> indicating wether <see cref="Texture" /> has
+        ///     changed in the last frame.
+        /// </summary>
+        protected static int DirtyTextureBitMask = BitVector32.CreateMask(UseDefaultProjectionBitMask);
+
+        /// <summary>
+        ///     The bitmask for use with <see cref="MatrixChainEffect.Flags" /> indicating wether the underlying vertex shader and
+        ///     fragment (pixel) shaders have changed to one of the pre-defined shaders in the last frame.
+        /// </summary>
+        protected static int DirtyShaderIndexBitMask = BitVector32.CreateMask(DirtyTextureBitMask);
+
+        /// <summary>
+        ///     The bitmask for use with <see cref="MatrixChainEffect.Flags" /> indicating wether the material color has changed in
+        ///     the last frame.
+        /// </summary>
+        public static int DirtyMaterialColorBitMask = BitVector32.CreateMask(DirtyShaderIndexBitMask);
+
+        private Texture2D _texture;
+        private EffectParameter _textureParameter;
+
+        private float _alpha = 1;
+        private Color _diffuseColor = Color.White;
+        private EffectParameter _diffuseColorParameter;
+
+        private bool _textureEnabled;
+        private bool _vertexColorEnabled;
+
+        /// <summary>
+        ///     Gets or sets the material <see cref="Texture2D" />.
+        /// </summary>
+        /// <value>
+        ///     The material <see cref="Texture2D" />.
+        /// </value>
+        public Texture2D Texture
+        {
+            get { return _texture; }
+            set
+            {
+                _texture = value;
+                Flags[DirtyTextureBitMask] = true;
+            }
+        }
+
+        /// <summary>
+        ///     Gets or sets the material color alpha.
+        /// </summary>
+        /// <remarks>
+        ///     <para>
+        ///         The alpha channel uses the premultiplied (associated) representation. This means that the RGB components of a
+        ///         color represent
+        ///         the color of the object of pixel, adjusted for its opacity by multiplication of <see cref="Alpha" />.
+        ///     </para>
+        /// </remarks>
+        public float Alpha
+        {
+            get { return _alpha; }
+
+            set
+            {
+                _alpha = value;
+                Flags[DirtyMaterialColorBitMask] = true;
+            }
+        }
+
+        /// <summary>
+        ///     Gets or sets whether texturing is enabled.
+        /// </summary>
+        public bool TextureEnabled
+        {
+            get { return _textureEnabled; }
+
+            set
+            {
+                if (_textureEnabled == value)
+                    return;
+                _textureEnabled = value;
+                Flags[DirtyShaderIndexBitMask] = true;
+            }
+        }
+
+        /// <summary>
+        ///     Gets or sets whether vertex color is enabled.
+        /// </summary>
+        public bool VertexColorEnabled
+        {
+            get { return _vertexColorEnabled; }
+
+            set
+            {
+                if (_vertexColorEnabled == value)
+                    return;
+                _vertexColorEnabled = value;
+                Flags[DirtyShaderIndexBitMask] = true;
+            }
+        }
+
+        /// <summary>
+        ///     Initializes a new instance of the <see cref="DefaultEffect" /> class.
+        /// </summary>
+        /// <param name="graphicsDevice">The graphics device.</param>
+        public DefaultEffect(GraphicsDevice graphicsDevice)
+            : base(graphicsDevice, EffectResource.DefaultEffect.Bytecode)
+        {
+            Initialize();
+        }
+
+        /// <summary>
+        ///     Initializes a new instance of the <see cref="DefaultEffect" /> class.
+        /// </summary>
+        /// <param name="graphicsDevice">The graphics device.</param>
+        /// <param name="byteCode">The byte code of the shader program.</param>
+        public DefaultEffect(GraphicsDevice graphicsDevice, byte[] byteCode)
+            : base(graphicsDevice, byteCode)
+        {
+            Initialize();
+        }
+
+        /// <summary>
+        ///     Initializes a new instance of the <see cref="DefaultEffect" /> class.
+        /// </summary>
+        /// <param name="cloneSource">The clone source.</param>
+        public DefaultEffect(Effect cloneSource)
+            : base(cloneSource)
+        {
+            Initialize();
+        }
+
+        private void Initialize()
+        {
+            Flags[DirtyMaterialColorBitMask] = true;
+            _textureParameter = Parameters["Texture"];
+            _diffuseColorParameter = Parameters["DiffuseColor"];
+        }
+
+        /// <summary>
+        ///     Computes derived parameter values immediately before applying the effect.
+        /// </summary>
+        protected override void OnApply()
+        {
+            base.OnApply();
+
+            if (Flags[DirtyTextureBitMask])
+            {
+                _textureParameter.SetValue(_texture);
+                Flags[DirtyTextureBitMask] = false;
+            }
+
+            // ReSharper disable once InvertIf
+            if (Flags[DirtyMaterialColorBitMask])
+            {
+                UpdateMaterialColor();
+                Flags[DirtyMaterialColorBitMask] = false;
+            }
+
+            // ReSharper disable once InvertIf
+            if (Flags[DirtyShaderIndexBitMask])
+            {
+                var shaderIndex = 0;
+
+                if (_textureEnabled)
+                    shaderIndex += 1;
+
+                if (_vertexColorEnabled)
+                    shaderIndex += 2;
+
+                Flags[DirtyShaderIndexBitMask] = false;
+                CurrentTechnique = Techniques[shaderIndex];
+            }
+        }
+
+        /// <summary>
+        ///     Updates the material color parameters associated with this <see cref="DefaultEffect" />.
+        /// </summary>
+        protected virtual void UpdateMaterialColor()
+        {
+            var diffuseColorVector3 = _diffuseColor.ToVector3();
+
+            var diffuseColorVector4 = new Vector4()
+            {
+                X = diffuseColorVector3.X * Alpha,
+                Y = diffuseColorVector3.Y * Alpha,
+                Z = diffuseColorVector3.Z * Alpha,
+                W = Alpha,
+            };
+
+            _diffuseColorParameter.SetValue(diffuseColorVector4);
+        }
+    }
+}
\ No newline at end of file
diff --git a/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/EffectResource.cs b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/EffectResource.cs
new file mode 100644
index 0000000..43bd535
--- /dev/null
+++ b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/EffectResource.cs
@@ -0,0 +1,119 @@
+using System;
+using System.Diagnostics;
+using System.IO;
+using System.Reflection;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+
+namespace MonoGame.Extended.Graphics.Effects
+{
+    /// <summary>
+    ///     Reperesents the bytecode of an <see cref="Effect" /> that is encapsulated inside a compiled assembly.
+    /// </summary>
+    /// <remarks>
+    ///     <para>
+    ///         Files that are encapsulated inside a compiled assembly are commonly known as Manifiest or embedded resources.
+    ///         Since embedded resources are added to the assembly at compiled time, they can not be accidentally deleted or
+    ///         misplaced. However, if the file needs to be changed, the assembly will need to be re-compiled with the changed
+    ///         file.
+    ///     </para>
+    ///     <para>
+    ///         To add an embedded resource file to an assembly, first add it to the project and then change the Build Action
+    ///         in the Properties of the file to <code>Embedded Resource</code>. The next time the project is compiled, the
+    ///         compiler will add the file to the assembly as an embedded resource. The compiler adds namespace(s) to the
+    ///         embedded resource so it matches with the path of where the file was added to the project.
+    ///     </para>
+    /// </remarks>
+    public class EffectResource
+    {
+        private static EffectResource _defaultEffect;
+        private static string _shaderExtension;
+
+        /// <summary>
+        ///     Gets the <see cref="Effects.DefaultEffect" /> embedded into the MonoGame.Extended.Graphics library.
+        /// </summary>
+        public static EffectResource DefaultEffect => _defaultEffect ?? (_defaultEffect = new EffectResource($"MonoGame.Extended.Graphics.Effects.Resources.DefaultEffect.{_shaderExtension}.mgfxo"));
+
+        static EffectResource()
+        {
+            DetermineShaderExtension();
+        }
+
+        private static void DetermineShaderExtension()
+        {
+            // use reflection to figure out if Shader.Profile is OpenGL (0) or DirectX (1),
+            // may need to be changed / fixed for future shader profiles
+
+            var assembly = typeof(Game).GetTypeInfo().Assembly;
+            Debug.Assert(assembly != null);
+
+            var shaderType = assembly.GetType("Microsoft.Xna.Framework.Graphics.Shader");
+            Debug.Assert(shaderType != null);
+            var shaderTypeInfo = shaderType.GetTypeInfo();
+            Debug.Assert(shaderTypeInfo != null);
+
+            // https://github.com/MonoGame/MonoGame/blob/develop/MonoGame.Framework/Graphics/Shader/Shader.cs#L47
+            var profileProperty = shaderTypeInfo.GetDeclaredProperty("Profile");
+            var value = (int)profileProperty.GetValue(null);
+
+            switch (value)
+            {
+                case 0:
+                    // OpenGL
+                    _shaderExtension = "ogl";
+                    break;
+                case 1:
+                    // DirectX
+                    _shaderExtension = "dx11";
+                    break;
+                default:
+                    throw new InvalidOperationException("Unknown shader profile.");
+            }
+        }
+
+        private readonly string _resourceName;
+        private volatile byte[] _bytecode;
+        private readonly Assembly _assembly;
+
+        /// <summary>
+        ///     Gets the bytecode of the <see cref="Effect" /> file.
+        /// </summary>
+        /// <value>
+        ///     The bytecode of the <see cref="Effect" /> file.
+        /// </value>
+        public byte[] Bytecode
+        {
+            get
+            {
+                if (_bytecode != null)
+                    return _bytecode;
+
+                lock (this)
+                {
+                    if (_bytecode != null)
+                        return _bytecode;
+
+                    var stream = _assembly.GetManifestResourceStream(_resourceName);
+                    using (var memoryStream = new MemoryStream())
+                    {
+                        stream.CopyTo(memoryStream);
+                        _bytecode = memoryStream.ToArray();
+                    }
+                }
+
+                return _bytecode;
+            }
+        }
+
+        /// <summary>
+        ///     Initializes a new instance of the <see cref="EffectResource" /> class.
+        /// </summary>
+        /// <param name="resourceName">The name of the embedded resource. This must include the namespace(s).</param>
+        /// <param name="assembly">The assembly which the embedded resource is apart of.</param>
+        public EffectResource(string resourceName, Assembly assembly = null)
+        {
+            _resourceName = resourceName;
+            _assembly = assembly ?? typeof(EffectResource).GetTypeInfo().Assembly;
+        }
+    }
+}
\ No newline at end of file
diff --git a/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/ITextureEffect.cs b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/ITextureEffect.cs
new file mode 100644
index 0000000..ea2ef0b
--- /dev/null
+++ b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/ITextureEffect.cs
@@ -0,0 +1,18 @@
+using Microsoft.Xna.Framework.Graphics;
+
+namespace MonoGame.Extended.Graphics.Effects
+{
+    /// <summary>
+    ///     Defines an <see cref="Effect" /> that uses a <see cref="Texture2D" />.
+    /// </summary>
+    public interface ITextureEffect
+    {
+        /// <summary>
+        ///     Gets or sets the <see cref="Texture2D" />.
+        /// </summary>
+        /// <value>
+        ///     The <see cref="Texture2D" />.
+        /// </value>
+        Texture2D Texture { get; set; }
+    }
+}
\ No newline at end of file
diff --git a/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/MatrixChainEffect.cs b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/MatrixChainEffect.cs
new file mode 100644
index 0000000..046479f
--- /dev/null
+++ b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/MatrixChainEffect.cs
@@ -0,0 +1,155 @@
+using System.Collections.Specialized;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+
+namespace MonoGame.Extended.Graphics.Effects
+{
+    /// <summary>
+    ///     An <see cref="Effect" /> that uses the standard chain of matrix transformations to represent a 3D object on a 2D
+    ///     monitor.
+    /// </summary>
+    /// <seealso cref="Effect" />
+    /// <seealso cref="IEffectMatrices" />
+    public abstract class MatrixChainEffect : Effect, IMatrixChainEffect
+    {
+        /// <summary>
+        ///     The bitmask for use with <see cref="Flags"/> indicating wether <see cref="World"/>, <see cref="View"/>, or <see cref="Projection"/> has changed in the last frame.
+        /// </summary>
+        protected static int DirtyWorldViewProjectionBitMask = BitVector32.CreateMask();
+
+        /// <summary>
+        ///     The bitmask for use with <see cref="Flags"/> indicating wether to use a default projection matrix or a custom projection matrix.
+        /// </summary>
+        protected static int UseDefaultProjectionBitMask = BitVector32.CreateMask(DirtyWorldViewProjectionBitMask);
+
+        /// <summary>
+        ///     The dirty flags associated with this <see cref="MatrixChainEffect"/>.
+        /// </summary>
+        protected BitVector32 Flags;
+
+        private Matrix _projection = Matrix.Identity;
+        private Matrix _view = Matrix.Identity;
+        private Matrix _world = Matrix.Identity;
+        private EffectParameter _matrixParameter;
+
+        /// <summary>
+        ///     Gets or sets the model-to-world <see cref="Matrix" />.
+        /// </summary>
+        /// <value>
+        ///     The model-to-world <see cref="Matrix" />.
+        /// </value>
+        public Matrix World
+        {
+            get { return _world; }
+            set { SetWorld(ref value); }
+        }
+
+        /// <summary>
+        ///     Gets or sets the world-to-view <see cref="Matrix" />.
+        /// </summary>
+        /// <value>
+        ///     The world-to-view <see cref="Matrix" />.
+        /// </value>
+        public Matrix View
+        {
+            get { return _view; }
+            set { SetView(ref value); }
+        }
+
+        /// <summary>
+        ///     Gets or sets the view-to-projection <see cref="Matrix" />.
+        /// </summary>
+        /// <value>
+        ///     The view-to-projection <see cref="Matrix" />.
+        /// </value>
+        public Matrix Projection
+        {
+            get { return _projection; }
+            set { SetProjection(ref value); }
+        }
+
+        /// <summary>
+        ///     Initializes a new instance of the <see cref="MatrixChainEffect" /> class.
+        /// </summary>
+        /// <param name="graphicsDevice">The graphics device.</param>
+        /// <param name="byteCode">The effect code.</param>
+        protected MatrixChainEffect(GraphicsDevice graphicsDevice, byte[] byteCode)
+            : base(graphicsDevice, byteCode)
+        {
+            Initialize();
+        }
+
+        /// <summary>
+        ///     Initializes a new instance of the <see cref="MatrixChainEffect" /> class.
+        /// </summary>
+        /// <param name="cloneSource">The clone source.</param>
+        protected MatrixChainEffect(Effect cloneSource)
+            : base(cloneSource)
+        {
+            Initialize();
+        }
+
+        private void Initialize()
+        {
+            Flags[UseDefaultProjectionBitMask] = true;
+
+            _matrixParameter = Parameters["WorldViewProjection"];
+        }
+
+        /// <summary>
+        ///     Sets the model-to-world <see cref="Matrix" />.
+        /// </summary>
+        /// <param name="world">The model-to-world <see cref="Matrix" />.</param>
+        public void SetWorld(ref Matrix world)
+        {
+            _world = world;
+            Flags[DirtyWorldViewProjectionBitMask] = true;
+        }
+
+        /// <summary>
+        ///     Sets the world-to-view <see cref="Matrix" />.
+        /// </summary>
+        /// <param name="view">The world-to-view <see cref="Matrix" />.</param>
+        public void SetView(ref Matrix view)
+        {
+            _view = view;
+            Flags[DirtyWorldViewProjectionBitMask] = true;
+        }
+
+        /// <summary>
+        ///     Sets the view-to-projection <see cref="Matrix" />.
+        /// </summary>
+        /// <param name="projection">The view-to-projection <see cref="Matrix" />.</param>
+        public void SetProjection(ref Matrix projection)
+        {
+            _projection = projection;
+            Flags[DirtyWorldViewProjectionBitMask] = true;
+            Flags[UseDefaultProjectionBitMask] = false;
+        }
+
+        /// <summary>
+        ///     Computes derived parameter values immediately before applying the effect.
+        /// </summary>
+        protected override void OnApply()
+        {
+            base.OnApply();
+
+            // ReSharper disable once InvertIf
+            if (Flags[DirtyWorldViewProjectionBitMask] || Flags[UseDefaultProjectionBitMask])
+            {
+                if (Flags[UseDefaultProjectionBitMask])
+                {
+                    var viewport = GraphicsDevice.Viewport;
+                    _projection = Matrix.CreateOrthographicOffCenter(0, viewport.Width, viewport.Height, 0, 0, -1);
+                }
+
+                Matrix worldViewProjection;
+                Matrix.Multiply(ref _world, ref _view, out worldViewProjection);
+                Matrix.Multiply(ref worldViewProjection, ref _projection, out worldViewProjection);
+                _matrixParameter.SetValue(worldViewProjection);
+
+                Flags[DirtyWorldViewProjectionBitMask] = false;
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/Resources/DefaultEffect.dx11.mgfxo b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/Resources/DefaultEffect.dx11.mgfxo
new file mode 100644
index 0000000..b83b6ed
--- /dev/null
+++ b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/Resources/DefaultEffect.dx11.mgfxo
diff --git a/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/Resources/DefaultEffect.fx b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/Resources/DefaultEffect.fx
new file mode 100644
index 0000000..30a772d
--- /dev/null
+++ b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/Resources/DefaultEffect.fx
@@ -0,0 +1,72 @@
+#include "Macros.fxh"
+#include "Structures.fxh"
+
+DECLARE_TEXTURE(Texture, 0);
+
+BEGIN_CONSTANTS
+
+float4 DiffuseColor = float4(1, 1, 1, 1);
+
+MATRIX_CONSTANTS
+
+float4x4 WorldViewProjection _vs(c0) _cb(c0);
+
+END_CONSTANTS
+
+VertexShaderOutputPosition VertexShaderFunctionPosition(VertexShaderInputPosition input)
+{
+	VertexShaderOutputPosition output;
+	output.Position = mul(input.Position, WorldViewProjection);
+	return output;
+}
+
+float4 PixelShaderFunctionPosition(VertexShaderOutputPosition input) : SV_Target0
+{
+	return DiffuseColor;
+}
+
+VertexShaderOutputPositionTexture VertexShaderFunctionPositionTexture(VertexShaderInputPositionTexture input)
+{
+	VertexShaderOutputPositionTexture output;
+	output.Position = mul(input.Position, WorldViewProjection);
+	output.TextureCoordinate = input.TextureCoordinate;
+	return output;
+}
+
+float4 PixelShaderFunctionPositionTexture(VertexShaderOutputPositionTexture input) : SV_Target0
+{
+	return SAMPLE_TEXTURE(Texture, input.TextureCoordinate) * DiffuseColor;
+}
+
+VertexShaderOutputPositionColor VertexShaderFunctionPositionColor(VertexShaderInputPositionColor input)
+{
+	VertexShaderOutputPositionColor output;
+	output.Position = mul(input.Position, WorldViewProjection);
+	output.Color = input.Color;
+	return output;
+}
+
+float4 PixelShaderFunctionPositionColor(VertexShaderOutputPositionColor input) : SV_Target0
+{
+	return input.Color * DiffuseColor;
+}
+
+VertexShaderOutputPositionColorTexture VertexShaderFunctionPositionColorTexture(VertexShaderInputPositionColorTexture input)
+{
+	VertexShaderOutputPositionColorTexture output;
+	output.Position = mul(input.Position, WorldViewProjection);
+	output.Color = input.Color;
+	output.TextureCoordinate = input.TextureCoordinate;
+	return output;
+}
+
+float4 PixelShaderFunctionPositionColorTexture(VertexShaderOutputPositionColorTexture input) : SV_Target0
+{
+	float4 textureColor = SAMPLE_TEXTURE(Texture, input.TextureCoordinate);
+	return textureColor * input.Color * DiffuseColor;
+}
+
+TECHNIQUE(Position, VertexShaderFunctionPosition, PixelShaderFunctionPosition);
+TECHNIQUE(PositionTexture, VertexShaderFunctionPositionTexture, PixelShaderFunctionPositionTexture);
+TECHNIQUE(PositionColor, VertexShaderFunctionPositionColor, PixelShaderFunctionPositionColor);
+TECHNIQUE(PositionColorTexture, VertexShaderFunctionPositionColorTexture, PixelShaderFunctionPositionColorTexture);
\ No newline at end of file
diff --git a/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/Resources/DefaultEffect.ogl.mgfxo b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/Resources/DefaultEffect.ogl.mgfxo
new file mode 100644
index 0000000..4f51d2a
--- /dev/null
+++ b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/Resources/DefaultEffect.ogl.mgfxo
diff --git a/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/Resources/Macros.fxh b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/Resources/Macros.fxh
new file mode 100644
index 0000000..c253efe
--- /dev/null
+++ b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/Resources/Macros.fxh
@@ -0,0 +1,60 @@
+//-----------------------------------------------------------------------------
+// Macros.fxh
+//
+// Microsoft XNA Community Game Platform
+// Copyright (C) Microsoft Corporation. All rights reserved.
+//-----------------------------------------------------------------------------
+
+#if SM4
+
+// Macros for targetting shader model 4.0 (DX11)
+
+#define TECHNIQUE(name, vsname, psname ) \
+	technique name { pass { VertexShader = compile vs_4_0_level_9_1 vsname (); PixelShader = compile ps_4_0_level_9_1 psname(); } }
+
+#define BEGIN_CONSTANTS     cbuffer Parameters : register(b0) {
+#define MATRIX_CONSTANTS
+#define END_CONSTANTS       };
+
+#define _vs(r)
+#define _ps(r)
+#define _cb(r)
+
+#define DECLARE_TEXTURE(Name, index) \
+    Texture2D<float4> Name : register(t##index); \
+    sampler Name##Sampler : register(s##index)
+
+#define DECLARE_CUBEMAP(Name, index) \
+    TextureCube<float4> Name : register(t##index); \
+    sampler Name##Sampler : register(s##index)
+
+#define SAMPLE_TEXTURE(Name, texCoord)  Name.Sample(Name##Sampler, texCoord)
+#define SAMPLE_CUBEMAP(Name, texCoord)  Name.Sample(Name##Sampler, texCoord)
+
+
+#else
+
+// Macros for targetting shader model 2.0 (DX9)
+
+#define TECHNIQUE(name, vsname, psname ) \
+	technique name { pass { VertexShader = compile vs_2_0 vsname (); PixelShader = compile ps_2_0 psname(); } }
+
+#define BEGIN_CONSTANTS
+#define MATRIX_CONSTANTS
+#define END_CONSTANTS
+
+#define _vs(r)  : register(vs, r)
+#define _ps(r)  : register(ps, r)
+#define _cb(r)
+
+#define DECLARE_TEXTURE(Name, index) \
+    sampler2D Name : register(s##index);
+
+#define DECLARE_CUBEMAP(Name, index) \
+    samplerCUBE Name : register(s##index);
+
+#define SAMPLE_TEXTURE(Name, texCoord)  tex2D(Name, texCoord)
+#define SAMPLE_CUBEMAP(Name, texCoord)  texCUBE(Name, texCoord)
+
+
+#endif
\ No newline at end of file
diff --git a/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/Resources/RebuildEffects.bat b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/Resources/RebuildEffects.bat
new file mode 100644
index 0000000..4fc7f21
--- /dev/null
+++ b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/Resources/RebuildEffects.bat
@@ -0,0 +1,15 @@
+setlocal
+
+SET TWOMGFX="mgfxc"
+
+@for /f %%f IN ('dir /b *.fx') do (
+
+  call %TWOMGFX% %%~nf.fx %%~nf.ogl.mgfxo /Profile:OpenGL
+
+  call %TWOMGFX% %%~nf.fx %%~nf.dx11.mgfxo /Profile:DirectX_11
+
+)
+
+endlocal
+
+pause
\ No newline at end of file
diff --git a/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/Resources/Structures.fxh b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/Resources/Structures.fxh
new file mode 100644
index 0000000..d3af6a0
--- /dev/null
+++ b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/Resources/Structures.fxh
@@ -0,0 +1,51 @@
+// Vertex shader input structures.
+
+struct VertexShaderInputPosition
+{
+    float4 Position : SV_Position;
+};
+
+struct VertexShaderInputPositionColor
+{
+    float4 Position : SV_Position;
+    float4 Color : COLOR;
+};
+
+struct VertexShaderInputPositionTexture
+{
+    float4 Position : SV_Position;
+    float2 TextureCoordinate : TEXCOORD0;
+};
+
+struct VertexShaderInputPositionColorTexture
+{
+    float4 Position : SV_Position;
+	float4 Color : COLOR;
+    float2 TextureCoordinate : TEXCOORD0;
+};
+
+// Vertex shader output structures.
+
+struct VertexShaderOutputPosition
+{
+    float4 Position : SV_Position;
+};
+
+struct VertexShaderOutputPositionColor
+{
+    float4 Position : SV_Position;
+    float4 Color : COLOR0;
+};
+
+struct VertexShaderOutputPositionTexture
+{
+    float4 Position : SV_Position;
+    float2 TextureCoordinate : TEXCOORD0;
+};
+
+struct VertexShaderOutputPositionColorTexture
+{
+    float4 Position : SV_Position;
+    float4 Color : COLOR0;
+	float2 TextureCoordinate : TEXCOORD0;
+};